Formatos de datos

El Glosario ESFC esta disponible en 8+ formatos para soportar diferentes casos de uso, desde aplicaciones web hasta integracion con la web semantica, consultas de bases de datos y programacion con seguridad de tipos.

Vision general

Todos los formatos se generan a partir de un unico esquema LinkML, asegurando consistencia entre las salidas mientras se optimiza cada formato para su caso de uso especifico.

Formatos disponibles:

Base de datos SQLite (133 MB)
JSON (189 MB)
LinkML YAML (157 MB)
JSON-LD (web semantica)
Tipos TypeScript
Ontologias RDF/OWL
Esquemas SQL DDL
CSV/Excel

Formatos principales

Base de datos SQLite

Archivo: glossary.db Tamano: 133 MB Caso de uso: Consultas, relaciones, integracion de aplicaciones

La base de datos SQLite proporciona almacenamiento optimizado y consultas rapidas para el glosario completo.

Esquema de la base de datos

-- Tabla principal de terminos
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
);

-- Indices para rendimiento
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);

-- Busqueda de texto completo
CREATE VIRTUAL TABLE terms_fts USING fts5(
  id, name, description, category,
  content=terms
);

-- Tabla de relaciones
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);

Ejemplos de consultas

Consultas basicas:

-- Contar terminos por fuente
SELECT source, COUNT(*) as term_count
FROM terms
GROUP BY source
ORDER BY term_count DESC;

-- Encontrar todos los terminos relacionados con trigo
SELECT id, name, source, category
FROM terms
WHERE name LIKE '%wheat%'
ORDER BY source, name;

-- Busqueda de texto completo
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;

Consultas avanzadas:

-- Encontrar terminos con relaciones
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;

-- Consultas jerarquicas
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;

Ejemplos de integracion

Python:

import sqlite3

# Conectar a la base de datos
conn = sqlite3.connect('glossary.db')
cursor = conn.cursor()

# Consultar terminos
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')

// Sentencia preparada
const stmt = db.prepare(`
  SELECT id, name, source, category
  FROM terms
  WHERE source = ? AND category LIKE ?
`)

const results = stmt.all('hestia', '%Emission%')
console.log(`Encontrados ${results.length} terminos de emision`)

Formato JSON

Archivo: glossary.json Tamano: 189 MB Caso de uso: Aplicaciones web, integracion JavaScript/TypeScript

Datos completos del glosario en formato JSON con detalles completos de terminos y metadatos.

Estructura

{
  "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"
    }
  ]
}

Ejemplos de uso

JavaScript/TypeScript:

// Cargar glosario
const glossary = await fetch('/glossary.json')
  .then(r => r.json())

// Filtrar por fuente
const hestiaTerms = glossary.terms.filter(t =>
  t.source === 'hestia'
)

// Buscar por nombre
const searchResults = glossary.terms.filter(t =>
  t.name.toLowerCase().includes('wheat')
)

// Agrupar por categoria
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)

# Acceder a metadatos
print(f"Version: {glossary['metadata']['version']}")
print(f"Total de terminos: {glossary['metadata']['totalTerms']}")

# Filtrar terminos
hestia_terms = [
    t for t in glossary['terms']
    if t['source'] == 'hestia'
]

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

LinkML YAML

Archivo: glossary.yaml Tamano: 157 MB Caso de uso: Web semantica, investigacion, validacion de datos

Formato nativo LinkML con anotaciones semanticas completas y relaciones.

Estructura

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

Uso con LinkML

Python con LinkML Runtime:

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

# Cargar glosario
glossary = yaml_loader.load('glossary.yaml', target_class=Glossary)

# Acceder a terminos
print(f"Cargados {len(glossary.terms)} terminos")

# Filtrar por fuente
hestia_terms = [t for t in glossary.terms if t.source == 'hestia']

# Validar contra el esquema
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 semantica)

Archivo: glossary.jsonld Tamano: ~200 MB Caso de uso: Web semantica, integracion RDF, datos enlazados

Formato JSON-LD con contexto de web semantica para integracion RDF/SPARQL.

Estructura

{
  "@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"
        }
      ]
    }
  ]
}

Consultas SPARQL

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

# Encontrar todos los terminos de trigo
SELECT ?term ?label ?source WHERE {
  ?term skos:prefLabel ?label ;
        dc:source ?source .
  FILTER(CONTAINS(LCASE(?label), "wheat"))
}
LIMIT 10

# Encontrar terminos relacionados
SELECT ?source ?target ?type WHERE {
  ?source skos:relatedMatch ?target .
  ?source dc:source "foodex2" .
  ?target dc:source "hestia" .
}

Formatos generados

Tipos TypeScript

Archivo: glossary.types.ts Tamano: ~500 KB Caso de uso: Integracion TypeScript/JavaScript con seguridad de tipos

Definiciones de tipos TypeScript generadas para el esquema del glosario.

Tipos generados

/**
 * Interfaz principal del glosario
 */
export interface Glossary {
  metadata: GlossaryMetadata
  terms: Term[]
}

/**
 * Metadatos sobre el glosario
 */
export interface GlossaryMetadata {
  version: string
  build: number
  lastUpdated: string
  totalTerms: number
  sources: Record<string, number>
}

/**
 * Termino individual del glosario
 */
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
}

/**
 * Fuentes del glosario
 */
export type GlossarySource =
  | 'foodex2'
  | 'hestia'
  | 'ecoinvent'
  | 'agrovoc'
  | 'langual'
  | 'cpc'
  | 'sentier'
  | 'unece'
  | 'gs1'
  | 'eaternity'

/**
 * Mapeo externo a otros vocabularios
 */
export interface ExternalMapping {
  externalId: string
  externalSource: string
  mappingType: 'exact' | 'related' | 'broader' | 'narrower'
  confidence?: number
}

/**
 * Estado del termino
 */
export type TermStatus = 'active' | 'deprecated' | 'obsolete'

Uso

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)
}

// Uso con seguridad de tipos
const glossary = await loadGlossary()
const hestiaTerms = filterBySource(glossary.terms, 'hestia')

// TypeScript asegura la seguridad de tipos
console.log(`Encontrados ${hestiaTerms.length} terminos de Hestia`)

Esquema SQL DDL

Archivo: glossary.sql Tamano: ~50 KB Caso de uso: Creacion de esquemas de bases de datos, configuracion PostgreSQL/MySQL

Definicion de esquema SQL para crear tablas de bases de datos.

Esquema generado

-- Tabla de terminos
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
);

-- Indices
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);

-- Busqueda de texto completo (PostgreSQL)
CREATE INDEX idx_terms_fts ON terms
USING gin(to_tsvector('english', coalesce(name, '') || ' ' || coalesce(description, '')));

-- Vista materializada para estadisticas de fuentes
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;

Ontologia RDF/OWL

Archivo: glossary.owl Tamano: ~250 MB Caso de uso: Aplicaciones de web semantica, razonamiento de ontologias

Ontologia OWL para razonamiento e inferencia en la web semantica.

Estructura de la ontologia

<?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>Ontologia del Glosario ESFC</rdfs:label>
    <rdfs:comment>
      Ontologia unificada de glosario de alimentos y Analisis del Ciclo de Vida
    </rdfs:comment>
  </owl:Ontology>

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

  <!-- Propiedades -->
  <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>

  <!-- Individuos (Terminos) -->
  <owl:NamedIndividual rdf:about="http://esfc-glossary.org/terms/foodex2-A010101">
    <rdf:type rdf:resource="http://esfc-glossary.org/ontology#Term"/>
    <skos:prefLabel>Trigo comun</skos:prefLabel>
    <skos:definition>Triticum aestivum, trigo panificable</skos:definition>
  </owl:NamedIndividual>

</rdf:RDF>

Formatos de exportacion

Exportacion CSV

Generad archivos CSV para subconjuntos especificos de terminos.

Estructura de exportacion

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 de exportacion

# Exportar todos los terminos a CSV
npm run export:csv

# Exportar fuente especifica
npm run export:csv -- --source hestia

# Exportar con filtros
npm run export:csv -- --source foodex2 --category Grains

Exportacion Excel

Libro de trabajo Excel con multiples hojas y datos organizados.

Estructura del libro

Hoja 1: Vision general

Metadatos y estadisticas
Resumen de fuentes
Desglose por categorias

Hoja 2: Todos los terminos

Lista completa de terminos
Columnas filtrables
Codificado por colores segun fuente

Hoja 3: FoodEx2

Terminos de FoodEx2 con jerarquia
Informacion de facetas

Hoja 4: Hestia

Terminos de Analisis del Ciclo de Vida de Hestia
Organizacion por categorias

Hoja 5: Relaciones

Mapeos entre fuentes
Puntuaciones de confianza
Metodos de mapeo

Generacion

# Generar libro de trabajo Excel
npm run export:excel

# Exportacion personalizada
node scripts/export-excel.js \
  --output glossary.xlsx \
  --include-relationships

Ubicaciones de descarga

Todos los formatos estan disponibles para descarga:

https://esfc-glossary-ec2bc9.gitlab.io/downloads/
├── glossary.db          # Base de datos SQLite (133 MB)
├── glossary.json        # Formato JSON (189 MB)
├── glossary.yaml        # LinkML YAML (157 MB)
├── glossary.jsonld      # JSON-LD (200 MB)
├── glossary.types.ts    # Tipos TypeScript (500 KB)
├── glossary.owl         # Ontologia OWL (250 MB)
├── glossary.sql         # SQL DDL (50 KB)
├── glossary.csv         # Exportacion CSV (variable)
└── glossary.xlsx        # Libro Excel (variable)

Guia de seleccion de formatos

Elegid el formato adecuado para vuestro caso de uso:

Caso de uso	Formato recomendado	Por que
Aplicacion web	JSON o SQLite	Carga rapida, facil integracion
Desarrollo con seguridad de tipos	Tipos TypeScript + JSON	Seguridad de tipos y autocompletado
Aplicacion de base de datos	SQLite o SQL DDL	Consultas optimizadas
Web semantica	JSON-LD o RDF/OWL	Compatibilidad RDF/SPARQL
Investigacion	LinkML YAML	Anotaciones semanticas completas
Analisis de datos	CSV o Excel	Herramientas de hojas de calculo
Integracion Python	SQLite o LinkML YAML	Soporte nativo
Integracion Node.js	JSON o SQLite	Analisis facil

Pipeline de generacion

Todos los formatos se generan a partir del esquema LinkML:

Esquema LinkML (glossary.linkml.yaml)
    ↓
Analisis y validacion de datos
    ↓
LinkML YAML (formato nativo)
    ↓
Generacion multiformato
    ├── JSON (linkml-convert)
    ├── JSON-LD (linkml-convert)
    ├── TypeScript (linkml-generate-typescript)
    ├── OWL (linkml-convert)
    ├── SQL DDL (linkml-generate-sql)
    └── SQLite (script personalizado)
    ↓
Optimizacion y compresion
    ↓
Despliegue en CDN

Documentacion relacionada

Fuentes de datos - Vision general de las 10 fuentes
Mapeo semantico - Relaciones entre fuentes
Vision general del glosario - Documentacion principal
Referencia de FoodEx2 - Clasificacion de alimentos
Referencia de Hestia - Datos de Analisis del Ciclo de Vida

Vision general​

Formatos principales​

Base de datos SQLite​

Esquema de la base de datos​

Ejemplos de consultas​

Ejemplos de integracion​

Formato JSON​

Estructura​

Ejemplos de uso​

LinkML YAML​

Estructura​

Uso con LinkML​

JSON-LD (Web semantica)​

Estructura​

Consultas SPARQL​

Formatos generados​

Tipos TypeScript​

Tipos generados​

Uso​

Esquema SQL DDL​

Esquema generado​

Ontologia RDF/OWL​

Estructura de la ontologia​

Formatos de exportacion​

Exportacion CSV​

Estructura de exportacion​

Scripts de exportacion​

Exportacion Excel​

Estructura del libro​

Generacion​

Ubicaciones de descarga​

Guia de seleccion de formatos​

Pipeline de generacion​

Documentacion relacionada​

Vision general

Formatos principales

Base de datos SQLite

Esquema de la base de datos

Ejemplos de consultas

Ejemplos de integracion

Formato JSON

Estructura

Ejemplos de uso

LinkML YAML

Estructura

Uso con LinkML

JSON-LD (Web semantica)

Estructura

Consultas SPARQL

Formatos generados

Tipos TypeScript

Tipos generados

Uso

Esquema SQL DDL

Esquema generado

Ontologia RDF/OWL

Estructura de la ontologia

Formatos de exportacion

Exportacion CSV

Estructura de exportacion

Scripts de exportacion

Exportacion Excel

Estructura del libro

Generacion

Ubicaciones de descarga

Guia de seleccion de formatos

Pipeline de generacion

Documentacion relacionada