Calculating a fields value according to the values of the previous and next fields

Question

For clarity assume that I have a table with a carID, a mileage and a date. The dates are always months (eg 01/02/2015, 01/03/2015, ...). Each carID has a row for each month, but not each row has values for the mileage field, some are NULL.

Example table:

carID           mileage           date
-----------------------------------------
1               400            01/01/2015
2               NULL           01/02/2015
3               NULL           01/03/2015
4               1050           01/04/2015

If such a field is NULL I need to calculate what value it should have by looking at the previous and next values (these aren't necessarily the next or previous month, they can be months apart).

I want to do this by taking the difference of the previous and next values, then calculate the time between them and make the value accordingly to the time. I have no idea however as how to do this.

I have already used a bit of code to look at the next value before, it looks like this:

, carKMcombiDiffList as (
select ml.*,
       (ml.KM - mlprev.KM) as diff
from carKMcombilist ml outer apply
     (select top 1 ml2.*
      from carKMcombilist ml2
      where ml2.FK_CarID = ml.FK_CarID and
            ml2.beginmonth < ml.beginmonth
      order by ml2.beginmonth desc
     ) mlprev
)

What this does is check if the current value is larger then the previous value. I assume I can use this as well to check the previous one in my current problem, I just don't know how I can add the next one in it AND all the logic that I need to make the calculations.

Answer 1

The following query obtains the previous and next available mileages for a record.

with data as --test data
(
    select * from (VALUES
        (0, null, getdate()),
        (1, 400, '20150101'),
        (1, null, '20150201'),
        (1, null, '20150301'),
        (1, 1050, '20150401'),
        (2, 300, '20150101'),
        (2, null, '20150201'),
        (2, null, '20150301'),
        (2, 1235, '20150401'),
        (2, null, '20150501'),
        (2, 1450, '20150601'),
        (3, 200, '20150101'),
        (3, null, '20150201')
    ) as v(carId, mileage, [date])
    where v.carId != 0
)
-- replace 'data' with your table name
select  d.*, 
        (select top 1 mileage from data dprev where dprev.mileage is not null and dprev.carId = d.carId and dprev.[date] <= d.date order by dprev.[date] desc) as 'Prev available mileage',
        (select top 1 mileage from data dnext where dnext.mileage is not null and dnext.carId = d.carId and dnext.[date] >= d.date order by dnext.[date] asc) as 'Next available mileage'
from    data d

Note that these columns can still be null if there is no data available before/after a specific date.

From here it's up to you on how you use these values. Probably you want to interpolate values for records where mileage is missing.

Edit

In order to interpolate the values for missing mileages I had to compute three auxiliary columns:

ri - index of record in a continuous group where mileage is missing
gi - index of a continuous group where mileage is missing per car
gc - count of records per continuous group where mileage is missing

The limit columns from the query above where renamed to
pa (Previous Available) and
na (Next Available).

The query is not compact and I am sure it can be improved but the good part of the cascading CTEs is that you can easily check intermediary results and understand each step.

SQL Fiddle: SO 29363187

with data as --test data
(
    select * from (VALUES
        (0, null, getdate()),
        (1, 400, '20150101'),
        (1, null, '20150201'),
        (1, null, '20150301'),
        (1, 1050, '20150401'),
        (2, 300, '20150101'),
        (2, null, '20150201'),
        (2, null, '20150301'),
        (2, 1235, '20150401'),
        (2, null, '20150501'),
        (2, 1450, '20150601'),
        (3, 200, '20150101'),
        (3, null, '20150201')
    ) as v(carId, mileage, [date])
    where v.carId != 0
),
-- replace 'data' with your table name
limits AS
(
    select  d.*, 
            (select top 1 mileage from data dprev where dprev.mileage is not null and dprev.carId = d.carId and dprev.[date] <= d.date order by dprev.[date] desc) as pa,
            (select top 1 mileage from data dnext where dnext.mileage is not null and dnext.carId = d.carId and dnext.[date] >= d.date order by dnext.[date] asc) as na
    from    data d
),
t1 as
(
    SELECT l.*,
           case when mileage is not null 
                then null 
                else row_number() over (partition by l.carId, l.pa, l.na  order by  l.carId, l.[date])
           end as ri,   -- index of record in a continuous group where mileage is missing
           case when mileage is not null 
                then null 
                else dense_rank() over (partition by carId order by  l.carId, l.pa, l.na)
           end as gi    -- index of  a continuous group where mileage is missing per car
    from limits l
),
t2 as
(
    select  *,
            (select count(*) from t1 tm where tm.carId = t.carId and tm.gi = t.gi)  gc  --count of records per continuous group where mileage is missing
    FROM    t1 t
)
select  *,
        case when mileage is NULL
            then pa + (na - pa) / (gc + 1.0) * ri   -- also converts from integer to decimal
            else NULL
        end as 'Interpolated value' 
from    t2
order by carId, [date]

Answer 2

Assumption: CarID and date are always a unique combination

This is what i came up with:

select with_dates.*,
       prev_mileage.mileage as prev_mileage,
       next_mileage.mileage as next_mileage,
       next_mileage.mileage - prev_mileage.mileage as mileage_delta,
       datediff(month,prev_d,next_d) as month_delta,
       (next_mileage.mileage - prev_mileage.mileage)/datediff(month,prev_d,next_d)*datediff(month,prev_d,with_dates.d) + prev_mileage.mileage as estimated_mileage
  from (select *,
          (select top 1 d
             from mileage as prev
            where carid = c.carid
              and prev.d < c.d
              and prev.mileage is not null
         order by d desc ) as prev_d,
           (select top 1 d
             from mileage as next_rec
            where carid = c.carid
              and next_rec.d > c.d
              and next_rec.mileage is not null
         order by d asc) as next_d
          from mileage as c
         where mileage is null) as with_dates
  join mileage as prev_mileage
    on     prev_mileage.carid = with_dates.carid
       and prev_mileage.d = with_dates.prev_d
  join mileage as next_mileage
    on     next_mileage.carid = with_dates.carid
       and next_mileage.d = with_dates.next_d

Logic: First, for every mileage is null record i select the previous and next date where mileage is not null . After this i just join the rows based on carid and date and do some simple math to approximate.

Hope this helps, it was quite fun.