“It’s not a bug, it’s a feature” PL/SQL like any other procedural extension to SQL has the ability to execute dynamic statements: EXECUTE IMMEDIATE. But not everyone knows it works differently for SQL statements and PL/SQL blocks. The difference lies in parameters passing.
Consider a simple example when we need to add a new row to a table using dynamic statement:
BEGIN
p_date := to_char(SYSDATE);
EXECUTE IMMEDIATE 'INSERT INTO test (created, modified, id, value)
VALUES ('||p_date||', '||p_date||', '||p_id||', '||p_value||')';
END;
It works, but has a serious flaw: a new statement is compiled for every set of parameters and for every call. We should use placeholders in the statement and pass values through USING clause. To my great surprise, even experienced Oracle programmers may have problems to do it right:
BEGIN
p_date := to_char(SYSDATE);
EXECUTE IMMEDIATE 'INSERT INTO test (created, modified, id, value)
VALUES (:p_date, :p_date, :p_id, :p_value)';
USING (p_date, p_id, p_value);
END;
Looks good? But id does not work. According to specification when calling SQL statements, Oracle does not even look at placeholders names but on number and order of placeholders – every placeholder needs precisely one argument on the USING list. The correct way to do it is:
BEGIN
p_date := to_char(SYSDATE);
EXECUTE IMMEDIATE 'INSERT INTO test (created, modified, id, value)
VALUES (:x, :x, :x, :x)';
USING (p_date, p_date, p_id, p_value);
END;
Notice repeated p_date in using clause. Repeating of the placeholder name is also intentional – i think it might help notice that one need to be cautious when modifying this piece of code. Now to make things even more confusing, assume that we add a procedure to insert that row but still need to call it dynamically. This time Oracle will behave differently: it will now look at placeholder names and will expect only one value per placeholder name:
BEGIN p_date := to_char(SYSDATE); EXECUTE IMMEDIATE 'BEGIN insert_into_test (:p_date, :p_date, :p_id, :p_value); END;'; USING (p_date, p_id, p_value); END;
Now the total weirdness: USING clause has no way of specifying placeholder name for each argument – here still only the order counts. Reading such a piece of code and trying to decipher which parameter gets which value may be painful:
BEGIN p_date := to_char(SYSDATE); EXECUTE IMMEDIATE 'BEGIN some_proc (:p_date, :p_user, :p_date, :p_id, :p_value, :p_user); END;'; USING (...???...); END;
Now imagine that the dynamic block consists of several calls with some common arguments and that the block itself is created programmatically… I bet one will quickly use unique placeholder names (like :p1, :p2, :p3,…) and pass each value multiple times or give up parameter passing entirely and use string concatenation method instead. And if you are still reading this – a short riddle:
EXECUTE IMMEDIATE 'call some_proc(:a, :a, :b, :c);' USING (...);
How many values should be passed here?
Couple of years ago I wasn't a big fan of unit testing. It was obvious to me that well prepared unit tests are crucial though. I didn't known why exactly crucial yet then. I just felt they are important. My disliking to write automation tests was mostly related to the effort necessary to prepare them. Also a spaghetti code was easily spotted in test sources.
