Question

I recently started working at a company with an enormous ‘enterprisey’ application. At my last job, I designed the database, but here we have a whole Database Architecture department that I’m not part of.

One of the stranger things in their database is that they have a bunch of views which, instead of having the user provide the date ranges they want to see, join with a (global temporary) table ‘TMP_PARM_RANG’ with a start and end date. Every time the main app starts processing a request, the first thing it does it ‘DELETE FROM TMP_PARM_RANG;’ then an insert into it.

This seems like a bizarre way of doing things, and not very safe, but everybody else here seems ok with it. Is this normal, or is my uneasiness valid?

Update I should mention that they use transactions and per-client locks, so it is guarded against most concurrency problems. Also, there are literally dozens if not hundreds of views that all depend on TMP_PARM_RANG.

Answer 1

Do I understand this correctly?

There is a view like this:

SELECT * FROM some_table, tmp_parm_rang   WHERE some_table.date_column BETWEEN tmp_parm_rang.start_date AND tmp_parm_rang.end_date; 

Then in some frontend a user inputs a date range, and the application does the following:

1. Deletes all existing rows from TMP_PARM_RANG
2. Inserts a new row into TMP_PARM_RANG with the user’s values
3. Selects all rows from the view

I wonder if the changes to TMP_PARM_RANG are committed or rolled back, and if so when? Is it a temporary table or a normal table? Basically, depending on the answers to these questions, the process may not be safe for multiple users to execute in parallel. One hopes that if this were the case they would have already discovered that and addressed it, but who knows?

Even if it is done in a thread-safe way, making changes to the database for simple query operations doesn’t make a lot of sense. These DELETEs and INSERTs are generating redo/undo (or whatever the equivalent is in a non-Oracle database) which is completely unnecessary.

A simple and more normal way of accomplishing the same goal would be to execute this query, binding the user’s inputs to the query parameters:

SELECT * FROM some_table WHERE some_table.date_column BETWEEN ? AND ?;