@mxpicture/tesla-superchargers-mate 0.1.56 → 0.1.58

package/db/schema.sql

@@ -2386,6 +2386,133 @@ CREATE VIEW public.pic_refs_base_v AS
    FROM row_no;
 
 
+--
+-- Name: pic_refs_hvac_v; Type: VIEW; Schema: public; Owner: -
+--
+
+CREATE VIEW public.pic_refs_hvac_v AS
+ WITH samples AS (
+         SELECT r.car_id,
+            r.ref_type,
+            r.ref_id,
+            r.start_date AS ref_start_date,
+            r.end_date AS ref_end_date,
+            p.id AS pos_id,
+            p.date,
+            p.is_climate_on,
+            p.is_rear_defroster_on,
+            p.is_front_defroster_on,
+            p.battery_heater
+           FROM (public.pic_refs r
+             JOIN public.positions p ON (((p.car_id = r.car_id) AND (p.drive_id = r.ref_id) AND (p.date >= r.start_date) AND (p.date <= r.end_date) AND (p.is_climate_on IS NOT NULL) AND (p.is_rear_defroster_on IS NOT NULL) AND (p.is_front_defroster_on IS NOT NULL) AND (p.battery_heater IS NOT NULL))))
+          WHERE ((r.ref_type = 'drive'::public.pic_ref_type) AND (r.ref_id > 0) AND (COALESCE(r.prev_id, 0) >= 0))
+        UNION ALL
+         SELECT r.car_id,
+            r.ref_type,
+            r.ref_id,
+            r.start_date AS ref_start_date,
+            r.end_date AS ref_end_date,
+            p.id AS pos_id,
+            p.date,
+            p.is_climate_on,
+            p.is_rear_defroster_on,
+            p.is_front_defroster_on,
+            p.battery_heater
+           FROM (public.pic_refs r
+             JOIN public.positions p ON (((p.car_id = r.car_id) AND (p.drive_id IS NULL) AND (p.date >= r.start_date) AND (p.date <= r.end_date) AND (p.is_climate_on IS NOT NULL) AND (p.is_rear_defroster_on IS NOT NULL) AND (p.is_front_defroster_on IS NOT NULL) AND (p.battery_heater IS NOT NULL))))
+          WHERE ((r.ref_type = ANY (ARRAY['idle'::public.pic_ref_type, 'charge'::public.pic_ref_type])) AND (r.ref_id > 0) AND (COALESCE(r.prev_id, 0) >= 0))
+        ), spans AS (
+         SELECT s_1.car_id,
+            s_1.ref_type,
+            s_1.ref_id,
+            s_1.ref_start_date,
+            s_1.ref_end_date,
+            s_1.pos_id,
+            s_1.date,
+            s_1.is_climate_on,
+            s_1.is_rear_defroster_on,
+            s_1.is_front_defroster_on,
+            s_1.battery_heater,
+            EXTRACT(epoch FROM (COALESCE(lead(s_1.date) OVER w, s_1.ref_end_date) -
+                CASE
+                    WHEN (row_number() OVER w = 1) THEN s_1.ref_start_date
+                    ELSE s_1.date
+                END)) AS duration_sec
+           FROM samples s_1
+          WINDOW w AS (PARTITION BY s_1.car_id, s_1.ref_type, s_1.ref_id ORDER BY s_1.date, s_1.pos_id)
+        )
+ SELECT car_id,
+    ref_type,
+    ref_id,
+    ref_start_date,
+    ref_end_date,
+    EXTRACT(epoch FROM (ref_end_date - ref_start_date)) AS ref_duration_sec,
+    sum(
+        CASE
+            WHEN is_climate_on THEN duration_sec
+            ELSE (0)::numeric
+        END) AS climate_on_sec,
+    sum(
+        CASE
+            WHEN is_rear_defroster_on THEN duration_sec
+            ELSE (0)::numeric
+        END) AS rear_defroster_sec,
+    sum(
+        CASE
+            WHEN is_front_defroster_on THEN duration_sec
+            ELSE (0)::numeric
+        END) AS front_defroster_sec,
+    sum(
+        CASE
+            WHEN battery_heater THEN duration_sec
+            ELSE (0)::numeric
+        END) AS battery_heater_sec,
+    sum(duration_sec) AS pos_total_sec,
+    count(*) AS pos_count,
+    min(date) AS pos_first_date,
+    max(duration_sec) AS max_gap_sec
+   FROM spans s
+  GROUP BY car_id, ref_type, ref_id, ref_start_date, ref_end_date;
+
+
+--
+-- Name: pic_refs_hvac_ratio_v; Type: VIEW; Schema: public; Owner: -
+--
+
+CREATE VIEW public.pic_refs_hvac_ratio_v AS
+ SELECT car_id,
+    ref_type,
+    ref_id,
+    ref_start_date,
+    ref_end_date,
+    ref_duration_sec,
+    climate_on_sec,
+    rear_defroster_sec,
+    front_defroster_sec,
+    battery_heater_sec,
+    pos_total_sec,
+    pos_count,
+    pos_first_date,
+    max_gap_sec,
+        CASE
+            WHEN (pos_total_sec > (0)::numeric) THEN round(LEAST((climate_on_sec / pos_total_sec), 1.0), 6)
+            ELSE NULL::numeric
+        END AS climate_on_ratio,
+        CASE
+            WHEN (pos_total_sec > (0)::numeric) THEN round(LEAST((rear_defroster_sec / pos_total_sec), 1.0), 6)
+            ELSE NULL::numeric
+        END AS rear_defroster_ratio,
+        CASE
+            WHEN (pos_total_sec > (0)::numeric) THEN round(LEAST((front_defroster_sec / pos_total_sec), 1.0), 6)
+            ELSE NULL::numeric
+        END AS front_defroster_ratio,
+        CASE
+            WHEN (pos_total_sec > (0)::numeric) THEN round(LEAST((battery_heater_sec / pos_total_sec), 1.0), 6)
+            ELSE NULL::numeric
+        END AS battery_heater_ratio
+   FROM public.pic_refs_hvac_v b;
+
+
 --
 -- Name: pic_refs_prep_v; Type: VIEW; Schema: public; Owner: -
 --

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/tesla-superchargers-mate",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "description": "TeslaMate integration",
   "type": "module",
   "author": "MXPicture",
@@ -50,7 +50,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mxpicture/tesla-superchargers-generated": "^0.1.56",
+    "@mxpicture/tesla-superchargers-generated": "^0.1.58",
     "dbmate": "2.35.1",
     "postgres": "^3.4.9",
     "short-uuid": "^6.0.3",

package/sql/reset.sql

@@ -31,6 +31,15 @@ DROP VIEW IF EXISTS pic_refs_prep_v;
 
 DROP VIEW IF EXISTS pic_refs_base_v;
 
+DROP VIEW IF EXISTS pic_refs_hvac_ratio_v;
+
+DROP VIEW IF EXISTS pic_refs_hvac_v;
+
+-- the pre-2026-09-06 names of the two above, for a database that still has them
+DROP VIEW IF EXISTS pic_refs_ratio_v;
+
+DROP VIEW IF EXISTS pic_refs_duration_v;
+
 DROP VIEW IF EXISTS pic_refs_v;
 
 DROP VIEW IF EXISTS pic_cp_chain_v;

package/sql/test/test.sql

@@ -0,0 +1,26 @@
+-- SELECT
+--   *
+-- FROM
+--   pic_refs_v
+-- ORDER BY
+--   start_date DESC
+-- LIMIT
+--   10;
+SELECT
+  *
+FROM
+  positions p
+WHERE
+  p.date >= to_timestamp(
+    '2026-09-06 10:10:17.521',
+    'YYYY-MM-DD HH24:MI:SS'
+  )
+  AND p.date <= to_timestamp(
+    '2026-09-06 10:33:06.469',
+    'YYYY-MM-DD HH24:MI:SS'
+  )
+ORDER BY
+  p.date,
+  p.id
+LIMIT
+  10;

package/sql/views-drop.sql

@@ -36,6 +36,20 @@ DROP VIEW IF EXISTS pic_refs_prep_v;
 
 DROP VIEW IF EXISTS pic_refs_base_v;
 
+DROP VIEW IF EXISTS pic_refs_hvac_ratio_v;
+
+DROP VIEW IF EXISTS pic_refs_hvac_v;
+
+-- RETIRED by rename, same rule as the group above: these are the names the two
+-- HVAC views carried before 2026-09-06 (pic_refs_duration_v read as "the
+-- duration of refs", which is pic_refs.hours -- a different thing). An existing
+-- database sheds them here; a database that never had them shrugs at the IF
+-- EXISTS. Delete these two lines once no database this code can reach still has
+-- them -- production carries them until the deploy that lands this rename.
+DROP VIEW IF EXISTS pic_refs_ratio_v;
+
+DROP VIEW IF EXISTS pic_refs_duration_v;
+
 DROP VIEW IF EXISTS pic_refs_v;
 
 DROP VIEW IF EXISTS pic_addresses_v;

package/sql/views.sql

@@ -1093,6 +1093,239 @@ WHERE
   -- opening balance anchored.
   AND COALESCE(r.prev_id, 0) >= 0;
 
+-- Per-ref HVAC duty, measured from the position samples inside the interval.
+--
+-- TeslaMate records is_climate_on, the two defrosters and battery_heater on
+-- every `positions` row as a state, not a duration: the sample says what was
+-- on at that instant and nothing about how long. So each sample is charged
+-- with the time until the next sample inside the same ref, and the last one
+-- runs to the ref's end_date -- a lead() chain of the same shape as
+-- pic_positions_chain_v, partitioned per ref instead of running over the whole
+-- table.
+--
+-- The same hold is applied at the head: the FIRST sample's span starts at the
+-- ref's start_date, not at the sample, so its state carries backwards over the
+-- lead-in exactly as the last sample's carries forwards over the tail. That
+-- makes pos_total_sec equal to ref_duration_sec by construction, so the
+-- seconds of one ref sum to its whole duration -- which is what lets them be
+-- summed across refs at all. Both columns stay, and
+-- `pos_total_sec <> ref_duration_sec` is then an assertion that this view is
+-- broken rather than a fact about the data.
+--
+-- lead() returns the next sample's date directly rather than its id, and the
+-- window orders by (date, id) rather than by id alone. Both matter. Ordering
+-- by id assumes positions.id order matches date order; the table already holds
+-- rows where it does not, and the failure would be silent -- negative spans
+-- inside otherwise plausible sums. Taking the date from lead() is what keeps
+-- the CTE referenced once: a second reference makes Postgres materialise it,
+-- and a materialised CTE cannot take a predicate, so every lookup of a single
+-- ref would first join the whole of positions against the whole of pic_refs.
+--
+-- The two ref types find their samples differently, which is why this is a
+-- UNION of two nearly identical halves rather than one join: a drive's
+-- positions carry its drive_id, a parked one carries none, and folding that
+-- into a CASE would cost each half its index. 'charge' rides along with 'idle'
+-- in the second half -- a charging process owns no position rows, but the car
+-- is parked and still polled inside the window, and those samples are where
+-- preconditioning and cabin pre-heat show up.
+--
+-- A sample missing any of the four flags is skipped rather than read as off:
+-- TeslaMate leaves them NULL when the car reported nothing, and counting NULL
+-- as off would silently deflate every share. The skip is a hole in the
+-- sampling, not in the timeline -- the previous usable sample's state carries
+-- straight across it. A ref with no usable sample at all does not appear here.
+--
+-- Because the hold is applied at both ends, pos_total_sec carries no
+-- information any more -- it is ref_duration_sec. What the row does not say on
+-- its own is how much of that duration was actually observed, and a share of a
+-- ref sampled twice reads exactly like a share of a ref sampled forty times.
+-- pos_count, pos_first_date and max_gap_sec are that missing signal, and cost
+-- nothing: they come out of the aggregate that is already running. max_gap_sec
+-- is the one to filter on -- the longest stretch a single sample was made to
+-- speak for. On this history it is minutes on a drive and up to two days on an
+-- idle gap the car slept through.
+--
+-- ref_id > 0 AND COALESCE(prev_id, 0) >= 0 is the pair of guards pic_refs_v
+-- applies, and it takes both: they catch different rows. The per-car seed is
+-- ref_id = -1 with a NULL prev_id, so only the first one sees it; the idle gap
+-- trailing the seed carries a positive sequence ref_id and prev_id = -1, so
+-- only the second one does. Both intervals are constructed -- endpoints
+-- derived rather than observed -- so a sample inside either would be charged
+-- with a span that never happened. The seed used to escape this view by being
+-- ref_type = 'charge'; matching charges (above) is what makes the explicit
+-- guard necessary, and production had exactly one usable sample sitting in
+-- that constructed hour.
+CREATE OR REPLACE VIEW pic_refs_hvac_v AS
+WITH
+  samples AS (
+    SELECT
+      r.car_id,
+      r.ref_type,
+      r.ref_id,
+      r.start_date AS ref_start_date,
+      r.end_date AS ref_end_date,
+      p.id AS pos_id,
+      p.date,
+      p.is_climate_on,
+      p.is_rear_defroster_on,
+      p.is_front_defroster_on,
+      p.battery_heater
+    FROM
+      pic_refs r
+      INNER JOIN positions p ON p.car_id = r.car_id
+      AND p.drive_id = r.ref_id
+      AND p.date >= r.start_date
+      AND p.date <= r.end_date
+      AND p.is_climate_on IS NOT NULL
+      AND p.is_rear_defroster_on IS NOT NULL
+      AND p.is_front_defroster_on IS NOT NULL
+      AND p.battery_heater IS NOT NULL
+    WHERE
+      r.ref_type = 'drive'
+      AND r.ref_id > 0
+      AND COALESCE(r.prev_id, 0) >= 0
+    UNION ALL
+    SELECT
+      r.car_id,
+      r.ref_type,
+      r.ref_id,
+      r.start_date AS ref_start_date,
+      r.end_date AS ref_end_date,
+      p.id AS pos_id,
+      p.date,
+      p.is_climate_on,
+      p.is_rear_defroster_on,
+      p.is_front_defroster_on,
+      p.battery_heater
+    FROM
+      pic_refs r
+      INNER JOIN positions p ON p.car_id = r.car_id
+      AND p.drive_id IS NULL
+      AND p.date >= r.start_date
+      AND p.date <= r.end_date
+      AND p.is_climate_on IS NOT NULL
+      AND p.is_rear_defroster_on IS NOT NULL
+      AND p.is_front_defroster_on IS NOT NULL
+      AND p.battery_heater IS NOT NULL
+    WHERE
+      r.ref_type IN ('idle', 'charge')
+      AND r.ref_id > 0
+      AND COALESCE(r.prev_id, 0) >= 0
+  ),
+  spans AS (
+    SELECT
+      s.*,
+      EXTRACT(
+        EPOCH
+        FROM
+          COALESCE(lead(s.date) OVER w, s.ref_end_date) - CASE
+            WHEN row_number() OVER w = 1 THEN s.ref_start_date
+            ELSE s.date
+          END
+      ) AS duration_sec
+    FROM
+      samples s
+    WINDOW
+      w AS (
+        PARTITION BY
+          s.car_id,
+          s.ref_type,
+          s.ref_id
+        ORDER BY
+          s.date,
+          s.pos_id
+      )
+  )
+SELECT
+  s.car_id,
+  s.ref_type,
+  s.ref_id,
+  s.ref_start_date,
+  s.ref_end_date,
+  EXTRACT(
+    EPOCH
+    FROM
+      s.ref_end_date - s.ref_start_date
+  ) AS ref_duration_sec,
+  sum(
+    CASE
+      WHEN s.is_climate_on THEN s.duration_sec
+      ELSE 0
+    END
+  ) AS climate_on_sec,
+  sum(
+    CASE
+      WHEN s.is_rear_defroster_on THEN s.duration_sec
+      ELSE 0
+    END
+  ) AS rear_defroster_sec,
+  sum(
+    CASE
+      WHEN s.is_front_defroster_on THEN s.duration_sec
+      ELSE 0
+    END
+  ) AS front_defroster_sec,
+  sum(
+    CASE
+      WHEN s.battery_heater THEN s.duration_sec
+      ELSE 0
+    END
+  ) AS battery_heater_sec,
+  sum(s.duration_sec) AS pos_total_sec,
+  count(*) AS pos_count,
+  min(s.date) AS pos_first_date,
+  max(s.duration_sec) AS max_gap_sec
+FROM
+  spans s
+GROUP BY
+  s.car_id,
+  s.ref_type,
+  s.ref_id,
+  s.ref_start_date,
+  s.ref_end_date;
+
+-- The same seconds as shares of the ref, one row for one row.
+--
+-- The guard is on the denominator, not inside LEAST. Postgres LEAST and
+-- GREATEST IGNORE their NULL arguments -- unlike Oracle and MySQL, the result
+-- is NULL only when every argument is -- so the obvious-looking
+-- LEAST(x / NULLIF(d, 0), 1.0) returns 1.0 for a zero denominator rather than
+-- NULL, and the row reports climate, both defrosters and the battery heater at
+-- 100 %. A ratio above 1 in a dashboard reads as data rather than as the
+-- arithmetic slip it is, and that one reads as a fully-loaded interval.
+--
+-- Since pos_total_sec is the ref's whole duration, a zero denominator now
+-- means a zero-length ref and nothing else. LEAST stays as the cap it was
+-- meant to be: with the spans tiling the ref exactly, no share can exceed 1
+-- by construction, so it is there to make a broken sum visible as a clamp
+-- rather than as a plausible number.
+CREATE OR REPLACE VIEW pic_refs_hvac_ratio_v AS
+SELECT
+  b.*,
+  CASE
+    WHEN b.pos_total_sec > 0 THEN round(LEAST(b.climate_on_sec / b.pos_total_sec, 1.0), 6)
+  END AS climate_on_ratio,
+  CASE
+    WHEN b.pos_total_sec > 0 THEN round(
+      LEAST(b.rear_defroster_sec / b.pos_total_sec, 1.0),
+      6
+    )
+  END AS rear_defroster_ratio,
+  CASE
+    WHEN b.pos_total_sec > 0 THEN round(
+      LEAST(b.front_defroster_sec / b.pos_total_sec, 1.0),
+      6
+    )
+  END AS front_defroster_ratio,
+  CASE
+    WHEN b.pos_total_sec > 0 THEN round(
+      LEAST(b.battery_heater_sec / b.pos_total_sec, 1.0),
+      6
+    )
+  END AS battery_heater_ratio
+FROM
+  pic_refs_hvac_v b;
+
 CREATE OR REPLACE VIEW pic_refs_base_v AS
 WITH
   cp AS (
@@ -1325,7 +1558,38 @@ WITH
   ),
   idle AS (
     SELECT
-      *
+      *,
+      -- Rated range that ROSE across a SHORT gap ending in a charge is the
+      -- charging process opening late, not the car standing still, and the
+      -- range belongs to the charge. Measured read-only against production on
+      -- 2026-09-06: range rises after 7 of the 9 drives a charge follows and
+      -- after 1 of the 315 a drive follows, so it is not a post-drive rebound;
+      -- and the real Tesla invoice (pic_invoices.quantity_base) bills energy
+      -- TeslaMate never logged, in the amount of the gap -- adopting it pulls
+      -- billed/logged from as high as 1.264 back into the 1.055-1.089 band
+      -- every gapless charge sits in. See
+      -- docs/plans/2026-09-06_pre-charge-idle-adoption.md.
+      --
+      -- Such a gap is absorbed into the charge by `collection` below rather
+      -- than kept as an idle ref. The bound is what separates it from a
+      -- charging session TeslaMate missed ENTIRELY -- 218.76 km over 47.9 h at
+      -- home -- which pic_build_costs_car prices at the fallback rate off its
+      -- _rebound_km branch and which must never be handed to the next charge's
+      -- invoice: that charge billed 1.70 EUR, and adopting 218.76 km into it
+      -- would price the energy at roughly nothing and under-price every drive
+      -- that drains it. The two populations are three orders of magnitude
+      -- apart -- the longest gap adopted here ran 2.8 min, the nearest one
+      -- excluded ran 47.9 h, and production holds nothing in between -- so the
+      -- bound is a duration, which separates them cleanly, rather than a
+      -- distance, which would have to guess at how fast a charger ramps.
+      --
+      -- The seed charge is out of reach by construction: it is every car's
+      -- first row, so no gap precedes it.
+      (
+        next_type = 'charge'::pic_ref_type
+        AND end_range_km > start_range_km
+        AND sec_to_next <= 600
+      ) AS adopted
     FROM
       chain
     WHERE
@@ -1346,28 +1610,54 @@ WITH
       -- row drops out here: an interval that has not ended yet is not priced.
       sec_to_next > 60
   ),
-  collection AS (
+  -- The gaps a charge takes over, keyed by the charge that takes them.
+  adoption AS (
     SELECT
-      t AS ref_type,
-      id::INTEGER AS ref_id,
       car_id,
+      next_id,
       start_date,
-      end_date,
-      start_range_km,
-      end_range_km,
+      start_range_km
+    FROM
+      idle
+    WHERE
+      adopted
+  ),
+  collection AS (
+    SELECT
+      b.t AS ref_type,
+      b.id::INTEGER AS ref_id,
+      b.car_id,
+      -- An adopted charge begins where the car parked rather than where
+      -- TeslaMate noticed it. A DELIBERATE divergence: for these rows
+      -- start_date and start_range_km no longer echo charging_processes'
+      -- start_date and start_rated_range_km. Both move together on purpose --
+      -- the range the charge gained has to be spread over the time it really
+      -- took, or mean_draw_kw reads high -- and because the absorbed idle no
+      -- longer sits between this row and the drive before it, the two now meet
+      -- exactly: the charge starts at the instant the drive ended, leaving
+      -- neither a gap for the queue to anchor across nor an overlap for
+      -- pic_refs_hvac_v to count a position twice in.
+      COALESCE(a.start_date, b.start_date) AS start_date,
+      b.end_date,
+      COALESCE(a.start_range_km, b.start_range_km) AS start_range_km,
+      b.end_range_km,
       NULL::pic_ref_type AS prev_type,
       NULL::INTEGER AS prev_id,
       NULL::pic_ref_type AS next_type,
       NULL::INTEGER AS next_id,
-      start_position_id,
-      end_position_id,
-      start_address_id,
-      end_address_id,
-      start_geofence_id,
-      end_geofence_id,
-      real_km
+      b.start_position_id,
+      b.end_position_id,
+      b.start_address_id,
+      b.end_address_id,
+      b.start_geofence_id,
+      b.end_geofence_id,
+      b.real_km
     FROM
-      pic_refs_base_v
+      pic_refs_base_v b
+      -- The type is part of the join: a drive and a charge can share an id.
+      LEFT JOIN adoption a ON a.car_id = b.car_id
+      AND a.next_id = b.id
+      AND b.t = 'charge'::pic_ref_type
     UNION ALL
     SELECT
       'idle'::pic_ref_type AS ref_type,
@@ -1390,6 +1680,8 @@ WITH
       NULL::NUMERIC AS real_km
     FROM
       idle
+    WHERE
+      NOT adopted
   )
 SELECT
   c.*,
@@ -1715,10 +2007,19 @@ DECLARE
   -- pic_energy_ledger_v's cfg used the same constant for a car that had never
   -- charged.
   _base_price CONSTANT NUMERIC := 0.40;
-  -- Rated range REBOUNDS after a drive (observed: +16.72 km within 1.3 min).
-  -- An idle gain below this is that artefact; a gain above it is energy that
-  -- really arrived and TeslaMate never logged. Same threshold the retired
-  -- pic_energy_ledger_v used for its rebound_km.
+  -- Rated range rebounds a little after a drive. An idle gain below this is
+  -- that artefact; a gain above it is energy that really arrived and TeslaMate
+  -- never logged. Same threshold the retired pic_energy_ledger_v used for its
+  -- rebound_km.
+  --
+  -- The +16.72 km within 1.3 min this constant was once justified by was NOT a
+  -- rebound: it was cp 18's pre-charge gap, which pic_refs_prep_v now adopts
+  -- into the charge, and measuring the rest of production put the true
+  -- post-drive rebound at 1.29 km or less. So the threshold is uncalibrated
+  -- between roughly 1.3 km and 20 km -- production holds no observation in
+  -- that band. It still earns its keep at the top of the range, where it
+  -- catches the 218.76 km home session TeslaMate slept through, and lowering
+  -- it would only start guessing in the empty middle.
   _rebound_km CONSTANT NUMERIC := 20.0;
 BEGIN
   -- Same lock as pic_build_refs_car: this procedure rewrites cost and

package/sql/test/drive_position3.sql

@@ -1,243 +0,0 @@
-WITH
-  base AS (
-    SELECT
-      p.car_id,
-      r.ref_type,
-      r.ref_id,
-      r.start_date AS ref_start_date,
-      r.end_date AS ref_end_date,
-      p.id AS pos_id,
-      p.drive_id,
-      p.is_climate_on,
-      p.is_rear_defroster_on,
-      p.is_front_defroster_on,
-      p.battery_heater
-    FROM
-      pic_refs r
-      LEFT JOIN positions p ON p.car_id = r.car_id
-      AND p.drive_id = r.ref_id
-      AND p.date >= r.start_date
-      AND p.date <= r.end_date
-      AND p.is_climate_on IS NOT NULL
-      AND p.is_rear_defroster_on IS NOT NULL
-      AND p.is_front_defroster_on IS NOT NULL
-      AND p.battery_heater IS NOT NULL
-    WHERE
-      r.ref_type = 'drive'
-    UNION ALL
-    SELECT
-      p.car_id,
-      r.ref_type,
-      r.ref_id,
-      r.start_date AS ref_start_date,
-      r.end_date AS ref_end_date,
-      p.id AS pos_id,
-      p.drive_id,
-      p.is_climate_on,
-      p.is_rear_defroster_on,
-      p.is_front_defroster_on,
-      p.battery_heater
-    FROM
-      pic_refs r
-      LEFT JOIN positions p ON p.car_id = r.car_id
-      AND p.drive_id IS NULL
-      AND p.date >= r.start_date
-      AND p.date <= r.end_date
-      AND p.is_climate_on IS NOT NULL
-      AND p.is_rear_defroster_on IS NOT NULL
-      AND p.is_front_defroster_on IS NOT NULL
-      AND p.battery_heater IS NOT NULL
-    WHERE
-      r.ref_type = 'idle'
-    ORDER BY
-      car_id,
-      ref_type,
-      ref_id,
-      ref_start_date,
-      ref_end_date
-  ),
-  base_chain_ids AS (
-    SELECT
-      car_id,
-      ref_type,
-      ref_id,
-      ref_start_date,
-      ref_end_date,
-      pos_id,
-      lead(pos_id) OVER (
-        PARTITION BY
-          car_id,
-          ref_type,
-          ref_id
-        ORDER BY
-          car_id,
-          ref_type,
-          ref_id,
-          ref_start_date,
-          ref_end_date,
-          pos_id
-      ) AS next_pos_id
-    FROM
-      base
-    ORDER BY
-      car_id,
-      ref_type,
-      ref_id,
-      ref_start_date,
-      ref_end_date
-  ),
-  base_pos AS (
-    SELECT
-      b.car_id,
-      b.ref_type,
-      b.ref_id,
-      b.ref_start_date,
-      b.ref_end_date,
-      b.pos_id,
-      b.next_pos_id,
-      p.date,
-      p.is_climate_on,
-      p.is_rear_defroster_on,
-      p.is_front_defroster_on,
-      p.drive_id,
-      p.battery_heater
-    FROM
-      base_chain_ids b
-      INNER JOIN positions p ON p.id = b.pos_id
-  ),
-  base_duration AS (
-    SELECT
-      b.*,
-      n.date AS next_date,
-      EXTRACT(
-        EPOCH
-        FROM
-          n.date
-      ) - EXTRACT(
-        EPOCH
-        FROM
-          b.date
-      ) AS duration_sec
-    FROM
-      base_pos b
-      LEFT JOIN base_pos n ON n.car_id = b.car_id
-      AND n.ref_type = b.ref_type
-      AND n.ref_id = b.ref_id
-      AND n.pos_id = b.next_pos_id
-    ORDER BY
-      b.car_id,
-      b.ref_type,
-      b.ref_id,
-      b.ref_start_date,
-      b.ref_end_date,
-      b.date
-  ),
-  condensed AS (
-    SELECT
-      b.car_id,
-      b.ref_type,
-      b.ref_id,
-      min(b.ref_start_date) AS ref_start_date,
-      max(b.ref_end_date) AS ref_end_date,
-      EXTRACT(
-        EPOCH
-        FROM
-          max(b.ref_end_date)
-      ) - EXTRACT(
-        EPOCH
-        FROM
-          min(b.ref_start_date)
-      ) AS ref_duration_sec,
-      sum(
-        CASE
-          WHEN b.is_climate_on THEN b.duration_sec
-          ELSE 0
-        END
-      ) AS climate_on_sec,
-      sum(
-        CASE
-          WHEN b.is_rear_defroster_on THEN b.duration_sec
-          ELSE 0
-        END
-      ) AS rear_defroster_sec,
-      sum(
-        CASE
-          WHEN b.is_front_defroster_on THEN b.duration_sec
-          ELSE 0
-        END
-      ) AS front_defroster_sec,
-      sum(
-        CASE
-          WHEN b.battery_heater THEN b.duration_sec
-          ELSE 0
-        END
-      ) AS battery_heater_sec,
-      sum(b.duration_sec) AS pos_total_sec
-    FROM
-      base_duration b
-    GROUP BY
-      b.car_id,
-      b.ref_type,
-      b.ref_id
-  ),
-  factored AS (
-    SELECT
-      b.*,
-      round(
-        LEAST(climate_on_sec / NULLIF(pos_total_sec, 0), 1.0),
-        6
-      ) AS climate_on_factor,
-      round(
-        LEAST(
-          rear_defroster_sec / NULLIF(pos_total_sec, 0),
-          1.0
-        ),
-        6
-      ) AS rear_defroster_factor,
-      round(
-        LEAST(
-          front_defroster_sec / NULLIF(pos_total_sec, 0),
-          1.0
-        ),
-        6
-      ) AS front_defroster_factor,
-      round(
-        LEAST(
-          battery_heater_sec / NULLIF(pos_total_sec, 0),
-          1.0
-        ),
-        6
-      ) AS battery_heater_factor
-    FROM
-      condensed b
-  )
-SELECT
-  b.*
-  -- min(b.pos_total_sec - b.ref_duration_sec) AS min_error_sec
-  -- max(b.pos_total_sec - b.ref_duration_sec) AS max_error_sec
-FROM
-  factored b
-  -- SELECT
-  --   b.car_id,
-  --   b.ref_type,
-  --   b.ref_id,
-  --   round(
-  --     b.climate_on_count::NUMERIC / b.total_count::NUMERIC,
-  --     4
-  --   ) AS climate_on_ratio,
-  --   round(
-  --     b.rear_defroster_count::NUMERIC / b.total_count::NUMERIC,
-  --     4
-  --   ) AS rear_defroster_ratio,
-  --   round(
-  --     b.front_defroster_count::NUMERIC / b.total_count::NUMERIC,
-  --     4
-  --   ) AS front_defroster_ratio,
-  --   round(
-  --     b.battery_heater_count::NUMERIC / b.total_count::NUMERIC,
-  --     4
-  --   ) AS battery_heater_ratio
-  -- FROM
-  --   condensed b
-  -- LIMIT
-  --   2000;