About Marvia.es

Marvia.es shows live and scheduled Renfe Cercanias Malaga C1/C2 train information for the Malaga rail network.

The Next train view focuses on one station at a time. When Renfe live data exists for an approaching train, it shows the official broadcast ETA and live data freshness.

When the station read path cannot produce a live ETA row, it falls back to the static timetable so the next scheduled C1/C2 departures are still visible. The Train map view plots live GPS train locations and, for a selected station, uses the same displayed ETA providers as the station snapshot endpoint.

Data Sources

Marvia.es consumes Renfe Operadora static GTFS and GTFS-Realtime feeds directly for the Malaga C1/C2 scope.

Attribution: Origen de los datos: Renfe Operadora
Static GTFS snapshot: Last update unavailable
License: CC-BY 4.0
Renfe links: Open-data portal / legal notice

Marvia.es is an unofficial app and is not affiliated with, endorsed by, or sponsored by Renfe. The open-data license covers reuse of the published data, not Renfe trademarks, wordmarks, or logos. This site does not use the Renfe wordmark or logo in a way that implies endorsement.

Open Data Sources / Fuentes de datos

Data Flow

The realtime poller fetches national Renfe feeds, narrows them to the C1/C2 Malaga scope before persistence, and stores filtered raw GTFS-Realtime rows for the web read path.

Persisted Table Schema

Discovery scanned the persisted table definitions in code: ADBC hot-store SQL in src/marvia/store/hot.py, the historical DuckDB schema in src/marvia/store.py, and the Iceberg table creator in src/marvia/warehouse.py. Indexes, sequences, and query-engine temporary views are not row tables, so they are not listed as persisted tables.

raw_responses_realtime, arrivals_board, arrivals_board_eta_results, and hot_store_flush_watermarks are created by the SQLite/PostgreSQL ADBC hot store.
raw_responses_realtime, arrivals_board, arrivals_board_eta_results, and static_gtfs_metadata are created by the historical DuckDB store.
marvia.raw_responses_realtime is created in the Iceberg warehouse with two additional partition columns.

`raw_responses_realtime` and Iceberg `marvia.raw_responses_realtime`

Sources: hot-store SQL in src/marvia/store/hot.py, DuckDB SCHEMA_SQL in src/marvia/store.py, and Iceberg schema/partition spec in src/marvia/warehouse.py.

Column	Real type(s)	Meaning
`id`	SQLite `INTEGER PRIMARY KEY AUTOINCREMENT`; PostgreSQL `BIGSERIAL PRIMARY KEY`; DuckDB `BIGINT PRIMARY KEY DEFAULT nextval(...)`; Iceberg `LongType required`	Monotonic persisted row identifier; the cold flush carries this id into Iceberg.
`feed_kind`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`; Iceberg `StringType required`; constrained to `trip_updates`, `vehicle_positions`, or `alerts`	Which GTFS-Realtime feed produced the row.
`captured_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`; Iceberg `TimestamptzType required`	UTC time when the poll response was captured.
`feed_header_timestamp`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`; Iceberg `TimestamptzType`	Publisher timestamp from the realtime feed header when Renfe sends one.
`request_url`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`; Iceberg `StringType required`	Exact Renfe feed URL requested.
`status_code`	SQLite/PostgreSQL `INTEGER` with HTTP-range check; DuckDB `USMALLINT`; Iceberg `IntegerType required`	HTTP response status for the poll.
`body_json`	SQLite `TEXT`; PostgreSQL `JSONB`; DuckDB `JSON`; Iceberg `StringType required`	JSON response body after the Malaga C1/C2 capture filter is applied.
`raw_payload`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`; Iceberg `StringType required`	Raw payload text after the same Malaga C1/C2 filter; used to preserve filtered raw fidelity.
`latency_ms`	SQLite `REAL`; PostgreSQL `DOUBLE PRECISION`; DuckDB `DOUBLE`; Iceberg `DoubleType required`	Measured request latency in milliseconds.
`http_headers_json`	SQLite `TEXT`; PostgreSQL `JSONB`; DuckDB `JSON`; Iceberg `StringType required`	Persisted HTTP response headers as JSON.
`captured_date`	Iceberg-only `StringType`; Arrow writer marks it non-null	UTC date partition key derived from `captured_at` as `YYYY-MM-DD`.
`captured_hour`	Iceberg-only `IntegerType`; Arrow writer marks it non-null	UTC hour partition key derived from `captured_at`, from 0 through 23.

`arrivals_board`

Sources: ADBC hot-store SQL in src/marvia/store/hot.py and DuckDB SCHEMA_SQL in src/marvia/store.py.

Column	Real type(s)	Meaning
`id`	SQLite `INTEGER PRIMARY KEY AUTOINCREMENT`; PostgreSQL `BIGSERIAL PRIMARY KEY`; DuckDB `BIGINT PRIMARY KEY DEFAULT nextval(...)`	Persisted board row id referenced by provider result rows.
`stop_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Station stop id whose board includes this arrival.
`direction_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Board direction bucket for the station.
`train_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Train or trip identity used for the visible arrival row.
`scheduled_arrival_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Scheduled arrival timestamp for this train at this stop; part of the uniqueness key.
`rank`	SQLite/PostgreSQL `INTEGER` checked between 1 and 3; DuckDB `USMALLINT` checked between 1 and 3	Published order within a station and direction.
`scheduled_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Scheduled timestamp used by the board computation for sorting and display.
`delay_seconds`	`INTEGER`	Delay reported or computed for the candidate, in seconds, when available.
`feed_captured_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Oldest relevant provider feed capture time attached to the board row.
`computed_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Time when the arrivals-board snapshot was computed.
`location_unknown`	SQLite `INTEGER` checked 0/1; PostgreSQL/DuckDB `BOOLEAN`	Whether the recompute could not locate the train between known stations.
`location_unavailable_reason`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Reason an unknown current location is unavailable: `NOT_YET_DEPARTED`, `TRIP_COMPLETED`, or `NO_SCHEDULE_MATCH`.
`at_station_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Current station stop id when the train is known to be at a station.
`at_station_name`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Display name for `at_station_id`.
`from_station_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Previous station stop id when the train is between stations.
`from_station_name`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Display name for `from_station_id`.
`to_station_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Next station stop id when the train is between stations.
`to_station_name`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Display name for `to_station_id`.
`current_timing_event_type`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Current timing signal event type from the board computation.
`current_timing_stop_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Stop id associated with the current timing signal.
`current_timing_stop_name`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Display name for `current_timing_stop_id`.
`current_timing_scheduled_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Scheduled timestamp for the current timing signal.
`current_timing_observed_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Observed timestamp for the current timing signal.
`current_timing_on_time`	SQLite `INTEGER` checked 0/1; PostgreSQL/DuckDB `BOOLEAN`	Whether the current timing signal is within the configured on-time threshold.
`current_timing_minutes_late`	`INTEGER`	Current timing lateness rounded to minutes.
`current_timing_unavailable_reason`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Reason current timing data could not be produced.
`broadcast_schedule_stop_id`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Stop id for the broadcast schedule signal.
`broadcast_schedule_stop_name`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Display name for `broadcast_schedule_stop_id`.
`broadcast_schedule_scheduled_arrival_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Scheduled arrival time paired with the official broadcast ETA.
`broadcast_schedule_eta_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Official broadcast ETA timestamp from Renfe when available.
`broadcast_schedule_on_time`	SQLite `INTEGER` checked 0/1; PostgreSQL/DuckDB `BOOLEAN`	Whether the broadcast schedule signal is considered on time.
`broadcast_schedule_minutes_late`	`INTEGER`	Broadcast schedule lateness rounded to minutes.
`broadcast_schedule_unavailable_reason`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	Reason broadcast schedule data could not be produced.

`arrivals_board_eta_results`

Sources: ADBC hot-store SQL in src/marvia/store/hot.py and DuckDB SCHEMA_SQL in src/marvia/store.py.

Column	Real type(s)	Meaning
`id`	SQLite `INTEGER PRIMARY KEY AUTOINCREMENT`; PostgreSQL `BIGSERIAL PRIMARY KEY`; DuckDB `BIGINT PRIMARY KEY DEFAULT nextval(...)`	Persisted provider-result row id.
`arrival_board_id`	SQLite `INTEGER`; PostgreSQL/DuckDB `BIGINT`; foreign key to `arrivals_board(id)`	Parent arrivals-board row this provider result belongs to.
`provider_name`	SQLite/PostgreSQL `TEXT`; DuckDB `VARCHAR`	ETA provider name, such as broadcast or physics.
`eta_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Provider-predicted arrival timestamp; required unless the row is marked declined.
`confidence`	SQLite `REAL`; PostgreSQL `DOUBLE PRECISION`; DuckDB `DOUBLE`; constrained to 0 through 1 when present	Provider confidence score when available.
`confidence_band_lower_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Lower timestamp bound for provider uncertainty when available.
`confidence_band_upper_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Upper timestamp bound for provider uncertainty when available.
`data_freshness_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Provider freshness timestamp exposed through the ETA result contract.
`source_feed_captured_at`	SQLite `TEXT`; PostgreSQL/DuckDB `TIMESTAMPTZ`	Capture time of the source feed used by this provider result.
`metadata_json`	SQLite `TEXT`; PostgreSQL `JSONB`; DuckDB `JSON`	Provider-specific metadata serialized as JSON.
`declined`	SQLite `INTEGER` checked 0/1; PostgreSQL/DuckDB `BOOLEAN`	Whether the provider intentionally declined to return an ETA.
`stale`	SQLite `INTEGER` checked 0/1; PostgreSQL/DuckDB `BOOLEAN`	Whether the provider result was based on stale input.

`static_gtfs_metadata`

Source: DuckDB SCHEMA_SQL in src/marvia/store.py; this table is not created by the ADBC hot store.

Column	Real type	Meaning
`id`	`BIGINT PRIMARY KEY DEFAULT nextval(...)`	Persisted metadata row id.
`fetched_at`	`TIMESTAMPTZ NOT NULL`	UTC time when the static GTFS archive was fetched.
`source_url`	`VARCHAR NOT NULL`	Renfe static GTFS zip URL.
`etag`	`VARCHAR`	ETag returned by Renfe for cache validation when present.
`last_modified`	`VARCHAR`	Last-Modified header returned by Renfe when present.
`zip_sha256`	`VARCHAR NOT NULL`	SHA-256 digest of the downloaded GTFS zip.
`zip_size_bytes`	`UBIGINT NOT NULL`	Size of the downloaded GTFS zip in bytes.
`manifest_json`	`JSON NOT NULL`	Static GTFS refresh manifest persisted as JSON.
`stored_path`	`VARCHAR`	Local path where the materialized static GTFS snapshot was stored.
`recorded_at`	`TIMESTAMPTZ NOT NULL DEFAULT now()`	Database-side time when the metadata row was recorded.

`hot_store_flush_watermarks`

Source: ADBC hot-store SQL in src/marvia/store/hot.py; this table tracks cold-path flush progress.

Column	Real type(s)	Meaning
`cursor_name`	SQLite/PostgreSQL `TEXT PRIMARY KEY`	Named flush cursor, for example the cold-path Iceberg cursor.
`last_row_id`	SQLite `INTEGER NOT NULL DEFAULT 0`; PostgreSQL `BIGINT NOT NULL DEFAULT 0`	Highest hot-store `raw_responses_realtime.id` durably consumed by the cursor.
`last_captured_at`	SQLite `TEXT`; PostgreSQL `TIMESTAMPTZ`	Capture timestamp for the last flushed realtime row.
`updated_at`	SQLite `TEXT NOT NULL`; PostgreSQL `TIMESTAMPTZ NOT NULL`	Time when the flush watermark was last updated.

Storage And Processing Technologies

Only technologies created or configured by the code are listed here; each entry points to the concrete module that proves it exists in the running architecture.

SQLite and PostgreSQL hot store through ADBC

The typed config selects sqlite locally and postgres for deployed profiles, and hot_store_from_config constructs SQLiteADBCHotStore or PostgresADBCHotStore using ADBC drivers. Evidence: src/marvia/config.py and src/marvia/store/hot.py.

DuckDB operational store and Iceberg query engine

The historical Storage class initializes DuckDB tables from SCHEMA_SQL. The cold read adapter installs and loads DuckDB's iceberg extension and reads table metadata through iceberg_scan(...). Evidence: src/marvia/store.py and src/marvia/query.py.

Iceberg warehouse with Parquet data files

load_or_create_realtime_iceberg_table creates the realtime warehouse table with an Iceberg schema and partition spec, while iceberg_table_properties sets write.format.default to parquet. Evidence: src/marvia/warehouse.py.

PyIceberg REST catalog

The config type is restricted to rest, and the catalog factory builds pyiceberg.catalog.rest.RestCatalog with configured URI and warehouse values. Evidence: src/marvia/config.py and src/marvia/catalog.py.

PyArrow FileIO over local files or S3-compatible storage

The warehouse FileIO helper always sets py-io-impl to pyiceberg.io.pyarrow.PyArrowFileIO, creates local file URIs for the local profile, and configures S3 endpoint properties when requested. Evidence: src/marvia/warehouse.py and src/marvia/config.py.

GTFS-Realtime and static GTFS ingestion

The poller configures Renfe's trip_updates.json, vehicle_positions.json, and alerts.json feeds with httpx; the static GTFS refresher downloads fomento_transit.zip and records metadata. Evidence: src/marvia/poller.py and src/marvia/static_gtfs.py.

Medallion `arrivals_board` precompute

compute_arrivals_board materializes parent board rows and provider result rows from immutable realtime/static snapshots before the hot store publishes them. Evidence: src/marvia/store/arrivals_board.py and src/marvia/store/hot.py.

Optional Spark Iceberg query engine

The query backend accepts spark, builds a Spark SQL Iceberg REST catalog configuration, and can wrap an existing Spark session behind the same read interface as DuckDB. Evidence: src/marvia/config.py and src/marvia/query.py.

ETA Providers

Broadcast is the displayed live provider column for live candidate trains. Physics runs as an internal baseline unless the operator includes it in the station provider display allow-list. Static GTFS is a fallback answer only when the station route cannot produce a live ETA row.

C1/C2 Network

The schematic follows the configured Malaga Cercanias station order: C1 to Fuengirola and C2 to Álora share the city trunk through Victoria Kent, then branch.

These diagrams are inline SVG embedded in this page. They do not use Mermaid, JavaScript rendering, or an external CDN.