This is funny to me. I just wrote a book entitled "Joe Celko's
Thinking in Sets: Auxiliary, Temporal, and Virtual Tables in SQL"
which is about using tables in place of computational code for the
working programmer.

My premise is that parallelism and fast, cheap storage (sold state
devices replacing moving disk) make this approach faster and more
portable than re-computing values over and over.

In real applications, the number of function values needed is
(whatever "small" is this week). My favorite personal example is
written up in "Data Mining on a Budget" (http://www.tdan.com/view-
perspectives/5343). I like it because
1) Computational approaches were too complex to work
2) I got paid in BBQ

When the auxiliary table does not have the value we want, then we can:
1) Throw an exception and let the application handle it.
2) Take time to compute it and insert the answer back into the
table.
3) Interpolate the answer, knowing that we are trading accuracy for
speed. This is often fine in statistical application.

I think it is a valid approach to keep SQL programming as declarative
as possible.

This is funny to me. I just wrote a book entitled "Joe Celko's
Thinking in Sets: Auxiliary, Temporal, and Virtual Tables in SQL"
which is about using tables in place of computational code for the
working programmer.

My premise is that parallelism and fast, cheap storage (sold state
devices replacing moving disk) make this approach faster and more
portable than re-computing values over and over.

In real applications, the number of function values needed is
(whatever "small" is this week). My favorite personal example is
written up in "Data Mining on a Budget" (http://www.tdan.com/view-
perspectives/5343). I like it because
1) Computational approaches were too complex to work
2) I got paid in BBQ

When the auxiliary table does not have the value we want, then we can:
1) Throw an exception and let the application handle it.
2) Take time to compute it and insert the answer back into the
table.
3) Interpolate the answer, knowing that we are trading accuracy for
speed. This is often fine in statistical application.

I think it is a valid approach to keep SQL programming as declarative
as possible.

This is funny to me. I just wrote a book entitled "Joe Celko's
Thinking in Sets: Auxiliary, Temporal, and Virtual Tables in SQL"
which is about using tables in place of computational code for the
working programmer.

My premise is that parallelism and fast, cheap storage (sold state
devices replacing moving disk) make this approach faster and more
portable than re-computing values over and over.

In real applications, the number of function values needed is
(whatever "small" is this week). My favorite personal example is
written up in "Data Mining on a Budget" (http://www.tdan.com/view-
perspectives/5343). I like it because
1) Computational approaches were too complex to work
2) I got paid in BBQ

When the auxiliary table does not have the value we want, then we can:
1) Throw an exception and let the application handle it.
2) Take time to compute it and insert the answer back into the
table.
3) Interpolate the answer, knowing that we are trading accuracy for
speed. This is often fine in statistical application.

I think it is a valid approach to keep SQL programming as declarative
as possible.

This is funny to me. I just wrote a book entitled "Joe Celko's
Thinking in Sets: Auxiliary, Temporal, and Virtual Tables in SQL"
which is about using tables in place of computational code for the
working programmer.

My premise is that parallelism and fast, cheap storage (sold state
devices replacing moving disk) make this approach faster and more
portable than re-computing values over and over.

In real applications, the number of function values needed is
(whatever "small" is this week). My favorite personal example is
written up in "Data Mining on a Budget" (http://www.tdan.com/view-
perspectives/5343). I like it because
1) Computational approaches were too complex to work
2) I got paid in BBQ

When the auxiliary table does not have the value we want, then we can:
1) Throw an exception and let the application handle it.
2) Take time to compute it and insert the answer back into the
table.
3) Interpolate the answer, knowing that we are trading accuracy for
speed. This is often fine in statistical application.

I think it is a valid approach to keep SQL programming as declarative
as possible.

This is funny to me. I just wrote a book entitled "Joe Celko's
Thinking in Sets: Auxiliary, Temporal, and Virtual Tables in SQL"
which is about using tables in place of computational code for the
working programmer.

My premise is that parallelism and fast, cheap storage (sold state
devices replacing moving disk) make this approach faster and more
portable than re-computing values over and over.

In real applications, the number of function values needed is
(whatever "small" is this week). My favorite personal example is
written up in "Data Mining on a Budget" (http://www.tdan.com/view-
perspectives/5343). I like it because
1) Computational approaches were too complex to work
2) I got paid in BBQ

When the auxiliary table does not have the value we want, then we can:
1) Throw an exception and let the application handle it.
2) Take time to compute it and insert the answer back into the
table.
3) Interpolate the answer, knowing that we are trading accuracy for
speed. This is often fine in statistical application.

I think it is a valid approach to keep SQL programming as declarative
as possible.

This is funny to me. I just wrote a book entitled "Joe Celko's
Thinking in Sets: Auxiliary, Temporal, and Virtual Tables in SQL"
which is about using tables in place of computational code for the
working programmer.

My premise is that parallelism and fast, cheap storage (sold state
devices replacing moving disk) make this approach faster and more
portable than re-computing values over and over.

In real applications, the number of function values needed is
(whatever "small" is this week). My favorite personal example is
written up in "Data Mining on a Budget" (http://www.tdan.com/view-
perspectives/5343). I like it because
1) Computational approaches were too complex to work
2) I got paid in BBQ

When the auxiliary table does not have the value we want, then we can:
1) Throw an exception and let the application handle it.
2) Take time to compute it and insert the answer back into the
table.
3) Interpolate the answer, knowing that we are trading accuracy for
speed. This is often fine in statistical application.

I think it is a valid approach to keep SQL programming as declarative
as possible.