Select with filter on function parameters, if specified - sql

Question

I have a function to try to match partial data to a database row.
I want it to find a match if the parameter is non null; if it's null it should ignore that parameter.
If one of the parameters has a value but finds no match, the query returns no rows.
In pseudocode, that's pretty much how it'd go:
get all rows where:
param_a matches col_a when param_b is not null else don't check this column
AND param_b matches col_b when param_b is not null else don't check this column
AND param_c matches col_c when param_c is not null else don't check this column
AND param_d matches col_d when param_d is not null else don't check this column
AND param_e matches col_e when param_e is not null else don't check this column
What I do right now:
SELECT * FROM table
WHERE nvl(param_a, col_a) = col_a
AND nvl(param_b, col_b) = col_b
AND nvl(param_c, col_c) = col_c
AND nvl(param_d, col_d) = col_d;
Etc... It works, but I'm not sure it's the best option. A colleague suggested that I use
SELECT * FROM table
WHERE (param_a = col_a or param_a is null)
AND (param_b = col_b or param_b is null)
AND (param_c = col_c or param_c is null)
AND (param_d = col_d or param_d is null);
As this is used for an auto-complete feature in a web application, the query is executed a lot, as the user types. Being fast is essential. The strictest columns are filtered first to reduce the number of rows to process.
Is either of these options preferable? If not, how would you do it?
EDIT:
I wrote the question to be generic, but to put it in context: in this case it's for addresses. param_a is actually postal code, param_b street name etc... The function gets the string the user writes (ex: 999 Random St, Fakestate, Countryland, 131ABD) and calls a procedure on it that tries to split it and returns a table containing address, city, country, etc... that is used by the select statement (which is the subject of the question).

Answer 1

I believe the second solution is better. It allows Oracle to skip evaluating colA/B/C/D is the corresponding parameter is null.
However, it would be cleaner and faster if you dynamically build the query.
For example either in sql or in a programming language you can do something like this:
whereClause = 'WHERE 1 = 1'
IF paramA is not null
then whereClause += ' AND param_a = col_a'
else if paramB is not null
then whereClause += ' AND param_b = col_b'
etc...
For indexes I would only index the commonly used column combinations. There are too many combinations to cover them all. Pick the ones that give you the most bang for your buck.

Answer 2

If you are trying to go at typing speed, then I would suggest the following approach. Create a separate query for each combination of parameters. This is a total of 24 queries, with the where clauses such as:
WHERE param_a = col_a
WHERE param_b = col_b
. . .
WHERE param_a = col_a and param_b = col_b
. . .
WHERE param_a = col_a and param_b = col_b and param_c = col_c and param_d = col_d
Then, precompile these twenty-four queries.
Then choose the appropriate query based on the current state of the parameters.
I would also add indexes, at a minimum:
table(param_a, param_b, param_c, param_d)
table(param_b, param_c, param_d, param_a)
table(param_c, param_d, param_a, param_b)
table(param_d, param_a, param_b, param_c)
This will at least cover all cases with one parameter. You might want to include other indexes for other parameters.