A: 

What about pulling the lines into your application and computing the previous value there?

Manuel
A: 

Create a stored procedure and use a cursor to iterate and produce rows.

Jason Cohen
A stored procedure in Access 2007?
David-W-Fenton
Yes! Use a VB function.
Jason Cohen
A: 

You can use the OVER statement to generate nicely increasing row numbers.

select
 rownr = row_number() over (order by id)
, value
from your_table

With the numbers, you can easily look up the previous row:

with numbered_rows
as (
    select
     rownr = row_number() over (order by id)
    , value
    from your_table
)
select
    cur.value
,   IsNull(prev.value,0)
from numbered_rows cur
left join numbered_rows prev on cur.rownr = prev.rownr + 1

Hope this is useful.

Andomar
What SQL dialect is that? It's certainly not Jet SQL.
David-W-Fenton
SQL Server 2005 (which I assumed was the back end behind Access here)
Andomar
+2  A: 

This is not an answer to your actual question.

Instead, I feel that you are approaching the problem from a wrong direction: In properly normalized relational databases the tuples ("rows") of each table should contain references to other db items instead of the actual values. Maintaining these relations between tuples belongs to the data insertion part of the codebase. That is, if containing the value of a tuple with closest, smaller id number really belongs into your data model.

If the requirement to know the previous value comes from the view part of the application - that is, a single view into the data that needs to format it in certain way - you should pull the contents out, sorted by id, and handle the requirement in view specific code.

In your case, I would assume that knowing the previous tuples' value really would belong in the view code instead of the database.

EDIT: You did mention that you store them separately and just want to make a query for it. Even still, application code would probably be the more logical place to do this combining.

Jukka Dahlbom
+1  A: 

This sql should perform better then the one you have above, although these type of queries tend to be a little performance intensive... so anything you can put in them to limit the size of the dataset you are looking at will help tremendously. For example if you are looking at a specific date range, put that in.

SELECT followup.value, 
    ( SELECT TOP 1 f1.VALUE 
      FROM followup as f1 
      WHERE f1.id<followup.id 
      ORDER BY f1.id DESC
    ) AS Prev_Value
FROM followup

HTH

Praesagus