> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Materialize

> Synchronisez des événements personnalisés depuis Materialize vers OneSignal pour déclencher des Journeys automatisés et des campagnes de messagerie personnalisées basées sur le comportement des utilisateurs en temps réel.

export const DATA_TYPE_0 = "view or table columns"

export const PLATFORM_0 = "Materialize"

export const COLUMN_HEADER_0 = "Materialize Column"

export const PROPERTIES_DESCRIPTION_0 = "JSON object with event metadata"

## Aperçu

L'intégration OneSignal + Materialize permet la synchronisation automatique des événements personnalisés depuis votre base de données de streaming Materialize vers OneSignal pour déclencher des campagnes de messagerie automatisées et des Journeys basés sur le comportement des utilisateurs en temps réel.

Materialize est une base de données de streaming compatible PostgreSQL qui maintient des vues mises à jour de manière incrémentielle de vos données, permettant l'analyse et le traitement d'événements en temps réel.

***

## Exigences

* Accès aux [Event Streams](/docs/en/event-streams) pour les événements de message sortants (Les limitations de forfait et les dépassements s'appliquent)
* Accès aux [Événements personnalisés](/docs/en/custom-events) pour la synchronisation des événements entrants (Les limitations de forfait et les dépassements s'appliquent)
* [Forfait de compte mis à jour](https://onesignal.com/pricing) (non disponible sur les applications gratuites)

### Materialize

* **Compte Materialize** avec accès à la console
* **Mot de passe d'application** pour l'authentification des outils externes
* **Vues matérialisées** ou tables contenant des données d'événements
* **Données d'événements** accessibles dans votre base de données Materialize

***

## Configuration

<Steps>
  <Step title="Obtenir les détails de connexion Materialize">
    Connectez-vous à la console Materialize et accédez à la page **Connect** pour trouver vos détails de connexion.
  </Step>

  <Step title="Créer un mot de passe d'application">
    Dans la console Materialize, créez un nouveau **Mot de passe d'application** pour que OneSignal l'utilise pour l'authentification.
  </Step>

  <Step title="Se connecter à OneSignal">
    Dans OneSignal, allez dans **Data > Integrations** et cliquez sur **Add Integration**.

    Sélectionnez **Materialize** et fournissez :

    * **Host:** Votre nom d'hôte Materialize (trouvé sous **External Tools** dans la page Connect de la console Materialize)
    * **Username:** Votre adresse e-mail (utilisée pour vous connecter à Materialize)
    * **Password:** Le mot de passe d'application créé à l'étape 2
    * **Database:** Nom de la base de données (facultatif, par défaut `materialize`)
  </Step>

  <Step title="Tester la connexion">
    Cliquez sur **Test** pour vérifier que la connexion fonctionne correctement.
  </Step>
</Steps>

***

### Mappage des données d'événement

Mappez vos {DATA_TYPE_0} {PLATFORM_0} au format des événements personnalisés de OneSignal :

| Champ OneSignal | {COLUMN_HEADER_0} | Description                     | Requis |
| --------------- | ----------------- | ------------------------------- | ------ |
| `name`          | `event_name`      | Identifiant de l'événement      | Oui    |
| `external_id`   | `user_id`         | Identifiant de l'utilisateur    | Oui    |
| `timestamp`     | `event_timestamp` | Quand l'événement s'est produit | Non    |
| `properties`    | `event_data`      | {PROPERTIES_DESCRIPTION_0}      | Non    |

### Exemple de vue d'événements en temps réel

```sql theme={null}
-- Real-time materialized view for recent events
CREATE MATERIALIZED VIEW analytics.recent_user_events AS
SELECT
    event_name,
    user_id,
    event_timestamp,
    event_properties,
    session_id,
    device_type
FROM raw_events.stream
WHERE event_timestamp >= NOW() - INTERVAL '1 day';
```

***

## Modes de traitement

### Vues matérialisées (recommandé)

Tirez parti du traitement en temps réel de Materialize en synchronisant depuis des vues matérialisées qui se mettent à jour automatiquement à l'arrivée de nouvelles données :

```sql theme={null}
-- High-value events materialized view
CREATE MATERIALIZED VIEW analytics.high_value_events AS
SELECT
    event_name,
    user_id,
    event_timestamp,
    event_properties || jsonb_build_object(
        'source', 'materialize',
        'value_tier', 'high'
    ) as event_properties
FROM raw_events.stream
WHERE (event_properties->>'value')::numeric > 100;
```

### Mode requête SQL

Écrivez des requêtes personnalisées compatibles PostgreSQL pour transformer vos données d'événements :

```sql theme={null}
-- Real-time user activity summary
SELECT
    'activity_summary' as event_name,
    user_id,
    NOW() as event_timestamp,
    jsonb_build_object(
        'events_last_hour', COUNT(*),
        'unique_sessions', COUNT(DISTINCT session_id),
        'total_value', SUM((event_properties->>'value')::numeric),
        'last_seen', MAX(event_timestamp)
    ) as event_properties
FROM analytics.recent_user_events
WHERE event_timestamp >= NOW() - INTERVAL '1 hour'
GROUP BY user_id
HAVING COUNT(*) >= 5;
```

### Traitement de flux en temps réel

```sql theme={null}
-- Progressive profiling view
CREATE MATERIALIZED VIEW analytics.user_progression AS
SELECT
    user_id,
    COUNT(*) as total_events,
    COUNT(DISTINCT event_name) as unique_event_types,
    MAX(event_timestamp) as last_activity,
    CASE
        WHEN COUNT(*) >= 50 THEN 'power_user'
        WHEN COUNT(*) >= 20 THEN 'active_user'
        WHEN COUNT(*) >= 5 THEN 'engaged_user'
        ELSE 'new_user'
    END as user_segment
FROM raw_events.stream
GROUP BY user_id;
```

***

## Limitations

* Materialize ne prend en charge que le moteur de synchronisation de base
* Les requêtes en temps réel peuvent consommer plus de ressources de calcul
* Les jointures complexes sur de grands ensembles de données doivent être optimisées
* Les vues matérialisées nécessitent des ressources de cluster continues

***

## FAQ

### Comment optimiser les performances en temps réel dans Materialize ?

Utilisez des index sur les colonnes fréquemment interrogées et envisagez de partitionner les grands ensembles de données d'événements par plages horaires pour de meilleures performances.

### Puis-je synchroniser depuis des tables et des vues matérialisées ?

Oui, OneSignal peut lire depuis des tables statiques et des vues matérialisées en temps réel dans Materialize.

### Comment fonctionne la synchronisation en temps réel ?

Materialize maintient des vues mises à jour de manière incrémentielle, donc OneSignal lira toujours l'état le plus récent de vos données sans surcharge de traitement supplémentaire.

***