Discretionary updates and opening a cursor from passed parameters

Question

I am trying to pass a list of item IDs into a procedure, and have the procedure loop through a cursor of those items, working out the length of columns and taking appropriate action when the length of the data threatens to exceed the length of the column.
For example:
drop table t;
create table t (itemid number, itemdesc varchar2(10));
insert into t values (1,'cat,rat');
insert into t values (2,'dog');
commit;If I attempt to append ',cow' to the end of item 1, that would error. But it would be OK for item 2. However, if I try to add ',vestibule' to either of the items, both should error.
So I have this procedure:
create or replace PROCEDURE item_change (p_item_list IN VARCHAR2,
                                  p_newword IN VARCHAR2)
IS
  v_addlength      number;
  v_maxlength   number;
BEGIN
  v_addlength := length(p_newword);
  execute immediate 'select max(length(itemdesc)) from t
                     where itemid in
                       (select * from table(sys.odcinumberlist('||p_item_list||')))' into v_maxlength ;
  if v_maxlength+v_addlength>10 then
    raise_application_error(-20001,'Too Long!');
  else
    execute immediate 'update t set itemdesc=itemdesc||'''||p_newword||''' where itemid in  (select * from table(sys.odcinumberlist('||p_item_list||')))';
    commit;
  end if;
END;
/As you can see, I workout what the maximum length of all items descriptions are for all possible items, and then providing adding the length of the new addition would NOT exceed the column length, I go ahead and append the new word to the description. It works fine, provided you stick to one case at a time:
SQL> exec item_change('1',',cow');
BEGIN item_change('1',',cow'); END;
ERROR at line 1:
ORA-20001: Too Long!
ORA-06512: at "SYS.ITEM_CHANGE", line 15
ORA-06512: at line 1
SQL> exec item_change('2',',cow');
PL/SQL procedure successfully completed.
SQL> select * from t;
    ITEMID ITEMDESC
      1 cat,rat
      2 dog,cowBut now the twist: if someone asks to modify both items, and the request is only valid for one of them, I nevertheless want to update the one that it's OK for, and skip the one that it isn't going to work. The way I thought to do this was, instead of the bit where I currently raise the application error, start looping through a cursor of itemIDs, evaluating each one's length in turn, and doing the update if the length computation is OK, and skipping it if not. In pseudo code (because this is what I can't get right!) I was thinking this:
create or replace PROCEDURE item_change (p_item_list IN VARCHAR2,
                                  p_newword IN VARCHAR2)
IS
  v_addlength      number;
  v_maxlength   number;
  v_wordlength     number;
  cursor c1 is select itemid, length(itemdesc) from t where itemid in (select * from table(sys.odcinumberlist(p_item_list)));
BEGIN
  v_addlength := length(p_newword);
  execute immediate 'select max(length(itemdesc)) from t
                     where itemid in
                       (select * from table(sys.odcinumberlist('||p_item_list||')))' into v_maxlength ;
  if v_maxlength+v_addlength>10 then
    for x in c1 loop
      select length(itemdesc) into v_wordlength from t where itemid=x.itemid;
      if v_wordlength+v_addlength <= 10 then
        --do the update!
      end if;
    end loop
  else
    execute immediate 'update t set itemdesc=itemdesc||'''||p_newword||''' where itemid in  (select * from table(sys.odcinumberlist('||p_item_list||')))';
    commit;
  end if;
END;
/Of course, this doesn't actually work, because the syntax for declaring the cursor is all wrong, which is what I'm really asking about.
In reality, I'm dealing with a table of millions of records, and a user might have selected hundreds of thousands of them to add words to. I can't afford to not update any of them just because one of them would breach its maximum possible description length. So I have to have a way to update those that can be updated and not attempt to update those where the update would cause things to go wrong. And I'm not allowed to just truncate the descriptions or the additions to fit: the things either have to be updated the way the user has specified, or not. (*Added later*: and I have to have a way of listing/reporting on which specific items are not updated if they are skipped because of length reasons).
Can anyone suggest either new syntax for the above code so that it does what I conceptually want it to do? Or, alternatively, a different sort of approach entirely?
Success would be to have table T in this example have its original data (1,'cat,rat' and 2,'dog'), and for me to issue the command:
exec item_change('1,2',',cow');...and have it say, 'Procedure Successfully completed', with the result that a select from t would show item 1 as 'cat,rat' and item 2 as 'dog,cow'.
Thank you in advance.

Answer 1

Just to be sure I understand this. You will get a list of items, which identify individual records, possibly in the 100's of thousands. For each of these items, you need to add a single word to the description column, recording which ones could not be updated.
Would an individual item in p_item_list ever result in multiple rows being updated, or is each item unique in the table?
Will p_newword always be a single word, or could there be multiple words e.g. 'cat, hat'? If there could be multiple words, is it an all or nothing update, or could you add cat but not hat for one item, both for another and neither for a third? If the words were of different lengths and the second word would fit but the first not would you add the second but not the first?
First, I would completely support Karthik's suggestion to use an array instead of a string list if you can get the caller to do that, if not, I would transform the list into an array in the procedure. The code that Karthic showed that generates the cursor loop could be used to generate the array. In fact, this potential solution more or less depends on that.
In the simplest case, that is, that the update is to be treated as single word, that is all or nothing, then I would be tempted to try something along the lines of this.
CREATE PROCEDURE item_change (p_item_list IN VARCHAR2,
                                      p_newword IN VARCHAR2)  IS
   item_list_tbl is TABLE OF VARCHAR2(50);
   l_item_list  item_list_tbl;
   l_num_errors NUMBER
   dml_errors EXCEPTION;
   PRAGMA EXCEPTION_INIT(dml_errors, -24381);
BEGIN
   SELECT TRIM(SUBSTR(str,INSTR(str, ',', 1,level)+1, INSTR(str, ',', 1,level+1)-INSTR(str, ',', 1,level)-1)) item
   BULK COLLECT INTO l_item_list
   FROM (SELECT ','||p_item_list||',' str FROM DUAL)
         CONNECT BY level <= LENGTH(str)-LENGTH(REPLACE(str,','))-1;
   FORALL i IN l_item_list.First .. l_item_list.Last SAVE EXCEPTIONS
      UPDATE t
      SET itemdesc = itemdesc||p_newword;
EXCEPTION
   WHEN dml_errors THEN
      l_num_errors := SQL%BULK_EXCEPTIONS.COUNT;
      FOR i IN 1 .. l_num_errors LOOP
         DEBMS_OUTPUT.Put_Line('Errors occurred for '||l_item_list(SQL%BULK_EXCEPTIONS(i).ERROR_INDEX));
      END LOOP;
END;Note that if your item list could really be 100's of thousands of items, or at least affect that many rows in the update, then you probably want to think about doing the FORALL UPDATE/BULK_EXCEPTIONS processing in a loop updating a "reasonable" number of items at a time.
Depending on what you need in terms of error reporting. I would use possible use a log table (perhaps a GTT) then query off that to report back to the user, or perhaps a collection to return to the user. Note that the collection approach could require significant memory, so if you are really expecting to update 100's of thousands of rows I would definitely go for a table of some kind.
You can see more about bulk collect [in the documentation|http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14261/tuning.htm#sthref2176]
Edited by: John Spencer on Aug 21, 2009 10:44 AM
Added link