Formats de données

Le Glossaire ESFC est disponible en 8+ formats pour répondre à différents cas d'utilisation, des applications web à l'intégration au web sémantique, en passant par les requêtes de base de données et la programmation typée.

Vue d'ensemble

Tous les formats sont générés à partir d'un unique schéma LinkML, garantissant la cohérence entre les sorties tout en optimisant chaque format pour son cas d'utilisation spécifique.

Formats disponibles :

Base de données SQLite (133 Mo)
JSON (189 Mo)
LinkML YAML (157 Mo)
JSON-LD (web sémantique)
Types TypeScript
Ontologies RDF/OWL
Schémas SQL DDL
CSV/Excel

Formats principaux

Base de données SQLite

Fichier : glossary.db Taille : 133 Mo Cas d'utilisation : Requêtes, relations, intégration applicative

La base de données SQLite offre un stockage optimisé et des requêtes rapides pour le glossaire complet.

Schéma de la base de données

-- Table principale des termes
CREATE TABLE terms (
  id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  description TEXT,
  source TEXT NOT NULL,
  category TEXT,
  properties JSON,
  external_mappings JSON,
  parent_terms JSON,
  metadata JSON,
  status TEXT DEFAULT 'active',
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Index pour les performances
CREATE INDEX idx_source ON terms(source);
CREATE INDEX idx_category ON terms(category);
CREATE INDEX idx_name ON terms(name);
CREATE INDEX idx_status ON terms(status);

-- Recherche plein texte
CREATE VIRTUAL TABLE terms_fts USING fts5(
  id, name, description, category,
  content=terms
);

-- Table des relations
CREATE TABLE relationships (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  source_term_id TEXT NOT NULL,
  target_term_id TEXT NOT NULL,
  relationship_type TEXT NOT NULL,
  confidence REAL,
  method TEXT,
  FOREIGN KEY (source_term_id) REFERENCES terms(id),
  FOREIGN KEY (target_term_id) REFERENCES terms(id)
);

CREATE INDEX idx_relationships_source ON relationships(source_term_id);
CREATE INDEX idx_relationships_target ON relationships(target_term_id);

Exemples de requêtes

Requêtes de base :

-- Compter les termes par source
SELECT source, COUNT(*) as term_count
FROM terms
GROUP BY source
ORDER BY term_count DESC;

-- Trouver tous les termes liés au blé
SELECT id, name, source, category
FROM terms
WHERE name LIKE '%wheat%'
ORDER BY source, name;

-- Recherche plein texte
SELECT t.id, t.name, t.source, t.category
FROM terms_fts fts
JOIN terms t ON fts.id = t.id
WHERE terms_fts MATCH 'carbon emission'
LIMIT 20;

Requêtes avancées :

-- Trouver les termes avec des relations
SELECT
  t1.id as source_id,
  t1.name as source_name,
  r.relationship_type,
  t2.name as target_name,
  t2.source as target_source,
  r.confidence
FROM terms t1
JOIN relationships r ON t1.id = r.source_term_id
JOIN terms t2 ON t2.id = r.target_term_id
WHERE t1.source = 'foodex2'
  AND t2.source = 'hestia'
ORDER BY r.confidence DESC
LIMIT 10;

-- Requêtes hiérarchiques
WITH RECURSIVE hierarchy AS (
  SELECT id, name, parent_terms, 1 as level
  FROM terms
  WHERE id = 'foodex2-A0101'

  UNION ALL

  SELECT t.id, t.name, t.parent_terms, h.level + 1
  FROM terms t
  JOIN hierarchy h
  WHERE json_extract(t.parent_terms, '$[0]') = h.id
)
SELECT * FROM hierarchy;

Exemples d'intégration

Python :

import sqlite3

# Connexion à la base de données
conn = sqlite3.connect('glossary.db')
cursor = conn.cursor()

# Interroger les termes
cursor.execute('''
  SELECT id, name, source, category
  FROM terms
  WHERE source = ?
  LIMIT 10
''', ('hestia',))

for row in cursor.fetchall():
    print(f"{row[0]}: {row[1]} ({row[2]})")

conn.close()

Node.js :

import Database from 'better-sqlite3'

const db = new Database('glossary.db')

// Requête préparée
const stmt = db.prepare(`
  SELECT id, name, source, category
  FROM terms
  WHERE source = ? AND category LIKE ?
`)

const results = stmt.all('hestia', '%Emission%')
console.log(`Found ${results.length} emission terms`)

Format JSON

Fichier : glossary.json Taille : 189 Mo Cas d'utilisation : Applications web, intégration JavaScript/TypeScript

Données complètes du glossaire au format JSON avec tous les détails et métadonnées des termes.

Structure

{
  "metadata": {
    "version": "0.1.2",
    "build": 6,
    "lastUpdated": "2025-12-08T02:54:36.996Z",
    "totalTerms": 168626,
    "sources": {
      "foodex2": 31601,
      "hestia": 36044,
      "ecoinvent": 33784,
      "agrovoc": 41447,
      "langual": 12836,
      "cpc": 4583,
      "sentier": 7731,
      "unece": 406,
      "gs1": 154,
      "eaternity": 40
    }
  },
  "terms": [
    {
      "@type": "Term",
      "id": "foodex2-A010101",
      "name": "Common wheat",
      "description": "Triticum aestivum, bread wheat",
      "source": "foodex2",
      "category": "Grains",
      "properties": {
        "hierarchyCode": "A010101",
        "scientificName": "Triticum aestivum",
        "level": 4
      },
      "external_mappings": [
        {
          "externalId": "hestia-crop-wheat",
          "externalSource": "hestia",
          "mappingType": "related"
        }
      ],
      "parent_terms": ["foodex2-A0101"],
      "metadata": {
        "searchable": true,
        "verified": true
      },
      "status": "active"
    }
  ]
}

Exemples d'utilisation

JavaScript/TypeScript :

// Charger le glossaire
const glossary = await fetch('/glossary.json')
  .then(r => r.json())

// Filtrer par source
const hestiaTerms = glossary.terms.filter(t =>
  t.source === 'hestia'
)

// Rechercher par nom
const searchResults = glossary.terms.filter(t =>
  t.name.toLowerCase().includes('wheat')
)

// Regrouper par catégorie
const byCategory = glossary.terms.reduce((acc, term) => {
  const cat = term.category || 'Uncategorized'
  if (!acc[cat]) acc[cat] = []
  acc[cat].push(term)
  return acc
}, {})

Python :

import json

with open('glossary.json') as f:
    glossary = json.load(f)

# Accéder aux métadonnées
print(f"Version: {glossary['metadata']['version']}")
print(f"Total terms: {glossary['metadata']['totalTerms']}")

# Filtrer les termes
hestia_terms = [
    t for t in glossary['terms']
    if t['source'] == 'hestia'
]

# Rechercher
wheat_terms = [
    t for t in glossary['terms']
    if 'wheat' in t['name'].lower()
]

LinkML YAML

Fichier : glossary.yaml Taille : 157 Mo Cas d'utilisation : Web sémantique, recherche, validation de données

Format natif LinkML avec annotations sémantiques complètes et relations.

Structure

terms:
  - '@type': Term
    id: foodex2-A010101
    name: Common wheat
    description: Triticum aestivum, bread wheat
    source: foodex2
    category: Grains
    properties:
      hierarchyCode: A010101
      scientificName: Triticum aestivum
      level: 4
    external_mappings:
      - externalId: hestia-crop-wheat
        externalSource: hestia
        mappingType: related
    parent_terms:
      - foodex2-A0101
    metadata:
      searchable: true
      verified: true
    status: active

Utilisation avec LinkML

Python avec LinkML Runtime :

from linkml_runtime.loaders import yaml_loader
from glossary_model import Glossary, Term

# Charger le glossaire
glossary = yaml_loader.load('glossary.yaml', target_class=Glossary)

# Accéder aux termes
print(f"Loaded {len(glossary.terms)} terms")

# Filtrer par source
hestia_terms = [t for t in glossary.terms if t.source == 'hestia']

# Valider selon le schéma
from linkml_runtime.utils.schemaview import SchemaView

schema = SchemaView('schema/glossary.linkml.yaml')
for term in glossary.terms[:10]:
    schema.validate_object(term, target_class='Term')

JSON-LD (Web sémantique)

Fichier : glossary.jsonld Taille : ~200 Mo Cas d'utilisation : Web sémantique, intégration RDF, données liées

Format JSON-LD avec contexte de web sémantique pour l'intégration RDF/SPARQL.

Structure

{
  "@context": {
    "@vocab": "http://esfc-glossary.org/vocab/",
    "skos": "http://www.w3.org/2004/02/skos/core#",
    "dc": "http://purl.org/dc/terms/",
    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
    "Term": "skos:Concept",
    "name": "skos:prefLabel",
    "description": "skos:definition",
    "source": "dc:source",
    "category": "skos:inScheme",
    "parent_terms": "skos:broader",
    "external_mappings": {
      "@id": "skos:relatedMatch",
      "@container": "@set"
    }
  },
  "@graph": [
    {
      "@type": "Term",
      "@id": "foodex2:A010101",
      "name": "Common wheat",
      "description": "Triticum aestivum, bread wheat",
      "source": "foodex2",
      "category": "Grains",
      "parent_terms": ["foodex2:A0101"],
      "external_mappings": [
        {
          "@id": "hestia:crop-wheat",
          "mappingType": "related"
        }
      ]
    }
  ]
}

Requêtes SPARQL

PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX dc: <http://purl.org/dc/terms/>

# Trouver tous les termes liés au blé
SELECT ?term ?label ?source WHERE {
  ?term skos:prefLabel ?label ;
        dc:source ?source .
  FILTER(CONTAINS(LCASE(?label), "wheat"))
}
LIMIT 10

# Trouver les termes liés
SELECT ?source ?target ?type WHERE {
  ?source skos:relatedMatch ?target .
  ?source dc:source "foodex2" .
  ?target dc:source "hestia" .
}

Formats générés

Types TypeScript

Fichier : glossary.types.ts Taille : ~500 Ko Cas d'utilisation : Intégration TypeScript/JavaScript typée

Définitions de types TypeScript générées pour le schéma du glossaire.

Types générés

/**
 * Interface principale du glossaire
 */
export interface Glossary {
  metadata: GlossaryMetadata
  terms: Term[]
}

/**
 * Métadonnées du glossaire
 */
export interface GlossaryMetadata {
  version: string
  build: number
  lastUpdated: string
  totalTerms: number
  sources: Record<string, number>
}

/**
 * Terme individuel du glossaire
 */
export interface Term {
  '@type': 'Term'
  id: string
  name: string
  description?: string
  source: GlossarySource
  category?: string
  properties?: Record<string, any>
  external_mappings?: ExternalMapping[]
  parent_terms?: string[]
  metadata?: Record<string, any>
  status: TermStatus
}

/**
 * Sources du glossaire
 */
export type GlossarySource =
  | 'foodex2'
  | 'hestia'
  | 'ecoinvent'
  | 'agrovoc'
  | 'langual'
  | 'cpc'
  | 'sentier'
  | 'unece'
  | 'gs1'
  | 'eaternity'

/**
 * Correspondance externe vers d'autres vocabulaires
 */
export interface ExternalMapping {
  externalId: string
  externalSource: string
  mappingType: 'exact' | 'related' | 'broader' | 'narrower'
  confidence?: number
}

/**
 * Statut du terme
 */
export type TermStatus = 'active' | 'deprecated' | 'obsolete'

Utilisation

import { Glossary, Term, GlossarySource } from './glossary.types'

async function loadGlossary(): Promise<Glossary> {
  const response = await fetch('/glossary.json')
  return response.json()
}

function filterBySource(
  terms: Term[],
  source: GlossarySource
): Term[] {
  return terms.filter(t => t.source === source)
}

// Utilisation typée
const glossary = await loadGlossary()
const hestiaTerms = filterBySource(glossary.terms, 'hestia')

// TypeScript garantit la sécurité des types
console.log(`Found ${hestiaTerms.length} Hestia terms`)

Schéma SQL DDL

Fichier : glossary.sql Taille : ~50 Ko Cas d'utilisation : Création de schéma de base de données, configuration PostgreSQL/MySQL

Définition de schéma SQL pour la création de tables de base de données.

Schéma généré

-- Table des termes
CREATE TABLE terms (
  id VARCHAR(255) PRIMARY KEY,
  name TEXT NOT NULL,
  description TEXT,
  source VARCHAR(50) NOT NULL,
  category VARCHAR(255),
  properties JSONB,
  external_mappings JSONB,
  parent_terms JSONB,
  metadata JSONB,
  status VARCHAR(50) DEFAULT 'active',
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Index
CREATE INDEX idx_terms_source ON terms(source);
CREATE INDEX idx_terms_category ON terms(category);
CREATE INDEX idx_terms_name ON terms USING gin(to_tsvector('english', name));
CREATE INDEX idx_terms_properties ON terms USING gin(properties);

-- Recherche plein texte (PostgreSQL)
CREATE INDEX idx_terms_fts ON terms
USING gin(to_tsvector('english', coalesce(name, '') || ' ' || coalesce(description, '')));

-- Vue matérialisée pour les statistiques par source
CREATE MATERIALIZED VIEW source_statistics AS
SELECT
  source,
  COUNT(*) as term_count,
  COUNT(DISTINCT category) as category_count,
  MIN(created_at) as first_added,
  MAX(updated_at) as last_updated
FROM terms
GROUP BY source;

Ontologie RDF/OWL

Fichier : glossary.owl Taille : ~250 Mo Cas d'utilisation : Applications du web sémantique, raisonnement ontologique

Ontologie OWL pour le raisonnement et l'inférence sur le web sémantique.

Structure de l'ontologie

<?xml version="1.0"?>
<rdf:RDF xmlns="http://esfc-glossary.org/ontology#"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:owl="http://www.w3.org/2002/07/owl#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:skos="http://www.w3.org/2004/02/skos/core#">

  <owl:Ontology rdf:about="http://esfc-glossary.org/ontology">
    <rdfs:label>ESFC Glossary Ontology</rdfs:label>
    <rdfs:comment>
      Ontologie unifiée du glossaire alimentaire et d'Analyse du Cycle de Vie
    </rdfs:comment>
  </owl:Ontology>

  <!-- Classes -->
  <owl:Class rdf:about="http://esfc-glossary.org/ontology#Term">
    <rdfs:label>Term</rdfs:label>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2004/02/skos/core#Concept"/>
  </owl:Class>

  <!-- Propriétés -->
  <owl:DatatypeProperty rdf:about="http://esfc-glossary.org/ontology#source">
    <rdfs:domain rdf:resource="http://esfc-glossary.org/ontology#Term"/>
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
  </owl:DatatypeProperty>

  <!-- Individus (Termes) -->
  <owl:NamedIndividual rdf:about="http://esfc-glossary.org/terms/foodex2-A010101">
    <rdf:type rdf:resource="http://esfc-glossary.org/ontology#Term"/>
    <skos:prefLabel>Common wheat</skos:prefLabel>
    <skos:definition>Triticum aestivum, bread wheat</skos:definition>
  </owl:NamedIndividual>

</rdf:RDF>

Formats d'export

Export CSV

Génération de fichiers CSV pour des sous-ensembles spécifiques de termes.

Structure de l'export

id,name,description,source,category,properties,status
foodex2-A010101,"Common wheat","Triticum aestivum",foodex2,Grains,"{""hierarchyCode"":""A010101""}",active
hestia-crop-wheat,"Wheat crop","Agricultural wheat production",hestia,"Inputs & Products","{}",active

Scripts d'export

# Exporter tous les termes en CSV
npm run export:csv

# Exporter une source spécifique
npm run export:csv -- --source hestia

# Exporter avec des filtres
npm run export:csv -- --source foodex2 --category Grains

Export Excel

Classeur Excel multi-feuilles avec données organisées.

Structure du classeur

Feuille 1 : Vue d'ensemble

Métadonnées et statistiques
Résumé des sources
Répartition par catégorie

Feuille 2 : Tous les termes

Liste complète des termes
Colonnes filtrables
Code couleur par source

Feuille 3 : FoodEx2

Termes FoodEx2 avec hiérarchie
Informations sur les facettes

Feuille 4 : Hestia

Termes d'Analyse du Cycle de Vie Hestia
Organisation par catégorie

Feuille 5 : Relations

Correspondances inter-sources
Scores de confiance
Méthodes de correspondance

Génération

# Générer le classeur Excel
npm run export:excel

# Export personnalisé
node scripts/export-excel.js \
  --output glossary.xlsx \
  --include-relationships

Emplacements de téléchargement

Tous les formats sont disponibles au téléchargement :

https://esfc-glossary-ec2bc9.gitlab.io/downloads/
├── glossary.db          # Base de données SQLite (133 Mo)
├── glossary.json        # Format JSON (189 Mo)
├── glossary.yaml        # LinkML YAML (157 Mo)
├── glossary.jsonld      # JSON-LD (200 Mo)
├── glossary.types.ts    # Types TypeScript (500 Ko)
├── glossary.owl         # Ontologie OWL (250 Mo)
├── glossary.sql         # SQL DDL (50 Ko)
├── glossary.csv         # Export CSV (variable)
└── glossary.xlsx        # Classeur Excel (variable)

Guide de sélection des formats

Choisissez le bon format pour votre cas d'utilisation :

Cas d'utilisation	Format recommandé	Pourquoi
Application web	JSON ou SQLite	Chargement rapide, intégration facile
Développement typé	Types TypeScript + JSON	Sécurité des types et autocomplétion
Application de base de données	SQLite ou SQL DDL	Requêtes optimisées
Web sémantique	JSON-LD ou RDF/OWL	Compatibilité RDF/SPARQL
Recherche	LinkML YAML	Annotations sémantiques complètes
Analyse de données	CSV ou Excel	Outils tableur
Intégration Python	SQLite ou LinkML YAML	Support natif
Intégration Node.js	JSON ou SQLite	Analyse facile

Pipeline de génération

Tous les formats sont générés à partir du schéma LinkML :

Schéma LinkML (glossary.linkml.yaml)
    ↓
Analyse et validation des données
    ↓
LinkML YAML (format natif)
    ↓
Génération multi-formats
    ├── JSON (linkml-convert)
    ├── JSON-LD (linkml-convert)
    ├── TypeScript (linkml-generate-typescript)
    ├── OWL (linkml-convert)
    ├── SQL DDL (linkml-generate-sql)
    └── SQLite (script personnalisé)
    ↓
Optimisation et compression
    ↓
Déploiement sur le réseau de diffusion de contenu

Documentation associée

Sources de données - Vue d'ensemble des 10 sources
Correspondance sémantique - Relations inter-sources
Vue d'ensemble du glossaire - Documentation principale
Référence FoodEx2 - Classification alimentaire
Référence Hestia - Données d'Analyse du Cycle de Vie

Vue d'ensemble​

Formats principaux​

Base de données SQLite​

Schéma de la base de données​

Exemples de requêtes​

Exemples d'intégration​

Format JSON​

Structure​

Exemples d'utilisation​

LinkML YAML​

Structure​

Utilisation avec LinkML​

JSON-LD (Web sémantique)​

Structure​

Requêtes SPARQL​

Formats générés​

Types TypeScript​

Types générés​

Utilisation​

Schéma SQL DDL​

Schéma généré​

Ontologie RDF/OWL​

Structure de l'ontologie​

Formats d'export​

Export CSV​

Structure de l'export​

Scripts d'export​

Export Excel​

Structure du classeur​

Génération​

Emplacements de téléchargement​

Guide de sélection des formats​

Pipeline de génération​

Documentation associée​

Vue d'ensemble

Formats principaux

Base de données SQLite

Schéma de la base de données

Exemples de requêtes

Exemples d'intégration

Format JSON

Structure

Exemples d'utilisation

LinkML YAML

Structure

Utilisation avec LinkML

JSON-LD (Web sémantique)

Structure

Requêtes SPARQL

Formats générés

Types TypeScript

Types générés

Utilisation

Schéma SQL DDL

Schéma généré

Ontologie RDF/OWL

Structure de l'ontologie

Formats d'export

Export CSV

Structure de l'export

Scripts d'export

Export Excel

Structure du classeur

Génération

Emplacements de téléchargement

Guide de sélection des formats

Pipeline de génération

Documentation associée