Symfony Profiler

[
  "route" => "app_home"
  "route_parameters" => [
    "_route" => "app_home"
    "_controller" => "App\Controller\HomeController::index"
  ]
  "request_uri" => "https://preprod.linko.ci/"
  "method" => "GET"
]

[
  "firewall_name" => "main"
  "authenticators" => 2
]

[
  "firewall_name" => "main"
  "authenticator" => "Symfony\Component\Security\Http\Authenticator\Debug\TraceableAuthenticator"
]

[
  "firewall_name" => "main"
  "authenticator" => "Symfony\Component\Security\Http\Authenticator\Debug\TraceableAuthenticator"
]

[
  "firewall_name" => "main"
  "authenticator" => "Symfony\Component\Security\Http\Authenticator\Debug\TraceableAuthenticator"
]

[
  "firewall_name" => "main"
  "authenticator" => "Symfony\Component\Security\Http\Authenticator\Debug\TraceableAuthenticator"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\HttpKernel\EventListener\DebugHandlersListener::configure"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\UX\Turbo\Request\RequestListener::__invoke"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\HttpKernel\EventListener\ValidateRequestListener::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Bridge\Doctrine\Middleware\IdleConnection\Listener::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\HttpKernel\EventListener\SessionListener::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\HttpKernel\EventListener\LocaleListener::setDefaultLocale"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\AssetMapper\AssetMapperDevServerSubscriber::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\HttpKernel\EventListener\RouterListener::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\HttpKernel\EventListener\LocaleListener::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Component\HttpKernel\EventListener\LocaleAwareListener::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Bundle\SecurityBundle\Debug\TraceableFirewallListener::configureLogoutUrlGenerator"
]

[
  "event" => "kernel.request"
  "listener" => "Symfony\Bundle\SecurityBundle\Debug\TraceableFirewallListener::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "EasyCorp\Bundle\EasyAdminBundle\EventListener\AdminRouterSubscriber::onKernelRequestPrettyUrls"
]

[
  "event" => "kernel.request"
  "listener" => "Knp\Bundle\PaginatorBundle\Subscriber\SlidingPaginationSubscriber::onKernelRequest"
]

[
  "event" => "kernel.request"
  "listener" => "EasyCorp\Bundle\EasyAdminBundle\EventListener\AdminRouterSubscriber::onKernelRequest"
]

[
  "event" => "kernel.controller"
  "listener" => "EasyCorp\Bundle\EasyAdminBundle\EventListener\AdminRouterSubscriber::onKernelController"
]

[
  "event" => "kernel.controller"
  "listener" => "Symfony\Bundle\FrameworkBundle\DataCollector\RouterDataCollector::onKernelController"
]

[
  "event" => "kernel.controller"
  "listener" => "Symfony\Component\HttpKernel\DataCollector\RequestDataCollector::onKernelController"
]

[
  "event" => "kernel.controller_arguments"
  "listener" => "Symfony\Component\Security\Http\EventListener\IsCsrfTokenValidAttributeListener::onKernelControllerArguments"
]

[
  "event" => "kernel.controller_arguments"
  "listener" => "Symfony\Component\Security\Http\EventListener\IsGrantedAttributeListener::onKernelControllerArguments"
]

[
  "event" => "kernel.controller_arguments"
  "listener" => "Symfony\Component\HttpKernel\EventListener\CacheAttributeListener::onKernelControllerArguments"
]

[
  "event" => "kernel.controller_arguments"
  "listener" => "ContainerX4LNeTQ\RequestPayloadValueResolverGhost01ca9cc::onKernelControllerArguments"
]

[
  "event" => "kernel.controller_arguments"
  "listener" => "Symfony\Component\HttpKernel\EventListener\ErrorListener::onControllerArguments"
]

[
  "params" => [
    "use_savepoints" => true
    "driver" => "pdo_pgsql"
    "idle_connection_ttl" => 600
    "host" => "127.0.0.1"
    "port" => 5432
    "user" => "linko_user"
    "password" => "<redacted>"
    "driverOptions" => []
    "defaultTableOptions" => []
    "dbname" => "linko_db"
    "serverVersion" => "15"
    "charset" => "utf8"
  ]
]

[
  "sql" => "SELECT COUNT(p0_.id) AS sclr_0 FROM prestataire p0_ WHERE p0_.status = ?"
  "params" => [
    1 => 1
  ]
  "types" => [
    1 => 5
  ]
]

[
  "sql" => "SELECT p0_.id AS id_0 FROM prestataire p0_"
]

[
  "sql" => "SELECT p0_.id AS id_0, p0_.name AS name_1, p0_.description AS description_2, p0_.qualites AS qualites_3, p0_.abonnement_status AS abonnement_status_4, p0_.created_at AS created_at_5, p0_.updated_at AS updated_at_6, p0_.url_alias AS url_alias_7, p0_.auto_generate_alias AS auto_generate_alias_8, p0_.uuid AS uuid_9, p0_.approval_status AS approval_status_10, p0_.approved_at AS approved_at_11, p0_.status AS status_12, p0_.user_id AS user_id_13, p0_.localisation_id AS localisation_id_14, p0_.profile_image_id AS profile_image_id_15 FROM prestataire p0_ WHERE p0_.status = ? AND p0_.id IN (9, 14, 7, 15, 28, 23, 25, 39, 24, 37, 33, 12)"
  "params" => [
    1 => 1
  ]
  "types" => [
    1 => 5
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 7
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 9
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 12
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 14
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 23
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 24
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 28
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 33
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 37
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 39
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 25
  ]
  "types" => [
    1 => 1
  ]
]

[
  "sql" => "SELECT t0.id AS id_1, t0.total_orders AS total_orders_2, t0.completed_orders AS completed_orders_3, t0.in_progress_orders AS in_progress_orders_4, t0.cancel_orders AS cancel_orders_5, t0.total_reviews AS total_reviews_6, t0.average_rating AS average_rating_7, t0.positive_reviews AS positive_reviews_8, t0.negative_reviews AS negative_reviews_9, t0.average_response_time AS average_response_time_10, t0.total_earnings AS total_earnings_11, t0.completion_rate AS completion_rate_12, t0.last_updated AS last_updated_13, t0.uuid AS uuid_14, t0.prestataire_id AS prestataire_id_15 FROM prestataire_stats t0 WHERE t0.prestataire_id = ?"
  "params" => [
    1 => 15
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "research_localisation_regions"
]

[
  "sql" => "SELECT l0_.id AS id_0, l0_.name AS name_1, l0_.type AS type_2, l0_.latitude AS latitude_3, l0_.longitude AS longitude_4, l0_.osm_id AS osm_id_5, l0_.code_ivoire AS code_ivoire_6, l0_.uuid AS uuid_7, l0_.created_at AS created_at_8, l0_.updated_at AS updated_at_9, l0_.url_alias AS url_alias_10, l0_.auto_generate_alias AS auto_generate_alias_11 FROM localisation l0_ WHERE l0_.type = ? ORDER BY l0_.name ASC"
  "params" => [
    1 => "REGION"
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 81
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_81"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 81
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 192
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_192"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 192
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 201
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_201"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 201
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 263
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_263"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 263
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 150
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_150"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 150
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 70
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_70"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 70
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 158
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_158"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 158
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 2
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_2"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 2
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 236
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_236"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 236
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 124
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_124"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 124
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 169
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_169"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 169
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 92
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_92"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 92
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 215
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_215"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 215
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 30
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_30"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 30
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 141
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_141"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 141
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 58
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_58"
]

[
  "sql" => """
    -- =============================================\n
    -- OBJECTIF : Compter tous les prestataires situés dans une région,\n
    --            y compris ses départements, communes et quartiers.\n
    -- METHODE :  Utilisation d'une CTE (Common Table Expression) récursive\n
    --            pour parcourir la hiérarchie géographique.\n
    -- =============================================\n
    \n
    -- Crée une table temporaire récursive nommée 'tem_hierarchy'\n
    -- Elle va stocker progressivement tous les niveaux de la hiérarchie\n
    WITH RECURSIVE tem_hierarchy AS (\n
        -- =========================================\n
        -- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)\n
        -- Sélectionne la région racine (niveau 0)\n
        -- =========================================\n
        SELECT \n
            id,           -- ID de la localisation\n
            name,         -- Nom de la localisation\n
            type,         -- Type (région/département/commune/quartier)\n
            0 AS level    -- Niveau hiérarchique (0 = région)\n
        FROM \n
            public.localisation\n
        WHERE \n
            id = ?     -- ID de la localité\n
        \n
        -- =========================================\n
        -- UNION ALL combine les résultats avec...\n
        -- =========================================\n
        UNION ALL\n
        \n
        -- =========================================\n
        -- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)\n
        -- Trouve tous les enfants du niveau précédent\n
        -- =========================================\n
        SELECT \n
            l.id, \n
            l.name, \n
            l.type, \n
            h.level + 1   -- Incrémente le niveau (+1 par rapport au parent)\n
        FROM \n
            public.localisation l\n
        -- Jointure avec la table de hiérarchie pour trouver les enfants\n
        JOIN \n
            public.localisation_hierarchie lh \n
            ON lh.child_id = l.id  -- Lie l'enfant à sa localisation\n
        -- Jointure récursive : référence 'tem_hierarchy' elle-même\n
        JOIN \n
            tem_hierarchy h \n
            ON lh.parent_id = h.id  -- Lie l'enfant à son parent déjà exploré\n
        -- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux\n
    )\n
    \n
    -- =============================================\n
    -- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES\n
    -- Compte tous les prestataires liés aux localisations trouvées\n
    -- =============================================\n
    SELECT \n
        COUNT(p.id) as count_presta  -- Résultat final : nombre de prestataires\n
    FROM \n
        public.prestataire p\n
    -- Jointure avec la hiérarchie complète\n
    INNER JOIN \n
        tem_hierarchy th \n
        ON th.id = p.localisation_id  -- Filtre les prestataires de la zone\n
    -- NOTE : INNER JOIN exclut les prestataires sans localisation valide
    """
  "params" => [
    1 => 58
  ]
  "types" => [
    1 => 2
  ]
]

[
  "sql" => "SELECT l0_.url_alias AS url_alias_0, l0_.id AS id_1 FROM localisation l0_ INNER JOIN entity_url_alias e1_ ON (e1_.entity_id = l0_.id) INNER JOIN entity_type_alias e2_ ON (e2_.id = e1_.type_alias_id) WHERE l0_.id = ? LIMIT 1"
  "params" => [
    1 => 99
  ]
  "types" => [
    1 => 1
  ]
]

[
  "key" => "prestataire_localisation_count_99"
]