FORALL全解析

最新推荐文章于 2024-08-31 17:45:31 发布
原创 最新推荐文章于 2024-08-31 17:45:31 发布 · 2.9k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

  FORALL语句会从PL/SQL引擎会向SQL引擎发送SQL语句，后者会向PL/SQL引擎返回结果。PL/SQL和SQL引擎之间的通信称为上下文切换。这种上下文切换存在一定的性能负载。


1、FORALL语句

  FORALL语句会从PL/SQL引擎向SQL引擎批量发送INSERT、UPDATE和DELETE语句，而不是每次发送一条语句。例如，考虑下面的数值型FOR循环会10次迭代执行INSERT语句：

FOR i IN 1..10 LOOP

    INSERT INTO table_name

    VALUES (...);

END LOOP;


  该INSERT语句会从PL/SQL引擎发送到SQL引擎10次。也就是说，会发生10次上下文其换。如果使用FORALL语句替换这个FOR循环，只需要发送一次INSERT语句，但是会执行10次。在这种情况下，在PL/SQL和SQL之间只会发生一次上下文切换。


FORALL语句具有如下结构

  1. FORALL loop_counter IN bounds_clause
  2. SQL_STATEMENT [SAVE EXCEPTIONS];

其中，bounds_clause是下面形式之一

  1. lower_limit..upper_limit  就是 1..10
  2. INDICES OF collection_name BETWEEN lower_limit..upper_limit
  3. VALUES OF collection_name

后面这俩，第二种形式INDICES OF会引用特定集合中单个元素的下标。这个集合也许是嵌套表，或者具有数字下标的联合数组

第三种形式VALUES OF会引用特定集合中单个元素的值，这个集合可能是嵌套表或者联合数组。

  接下来，SQL_STATEMENT是引用一个或者多个集合的静态或者动态的INSERT、UPDATE或者DELETE语句。最后，即使当SQL_STATEMENT导致异常时，选项SAVE EXCEPTIONS仍旧能够保证FORALL语句继续执行


实验前创建表

CREATE TABLE test(row_num number,row_text varchar2(10));

  1. declare
  2.     type row_num_type is table of number index by simple_integer;
  3.     type row_text_type is table of varchar2(10) index by simple_integer;
  4.     row_num_tab row_num_type;
  5.     row_text_tab row_text_type;
  6.     v_total number;
  7. begin
  8.     for i in 1..10 loop
  9.         row_num_tab(i) := i;
  10.         row_text_tab(i) := 'row'||i;
  11.     end loop;
  13.     forall i in 1..10 
  14.         insert into test(row_num,row_text)
  15.         values (row_num_tab(i),row_text_tab(i));
  16.     commit;
  18.     select count(*) into v_total from test;
  20.     dbms_output.put_line(v_total||' rows insterted');
  21. end;
  22. /

结合动态sql

  1. declare
  2.     type row_num_type is table of number index by simple_integer;
  3.     type row_text_type is table of varchar2(10) index by simple_integer;
  4.     row_num_tab row_num_type;
  5.     row_text_tab row_text_type;
  6.     v_total number;
  7.     sql_stmt varchar2(300);
  8. begin
  9.     for i in 1..10 loop
  10.         row_num_tab(i) := i;
  11.         row_text_tab(i) := 'row'||i;
  12.     end loop;
  14.     sql_stmt := 'insert into test(row_num,row_text) values (:1,:2)';
  15.     forall i in 1..10 
  16.         execute immediate sql_stmt using row_num_tab(i),row_text_tab(i);
  17.     commit;
  18.     select count(*) into v_total from test;
  19.     dbms_output.put_line(v_total||' rows insterted');
  20. end;
  21. /
  23. 10 rows insterted
  25. PL/SQL procedure successfully completed.


  

比较for loop和forall statement时间差异

这里用到dbms_utility.get_time包,精度为百分之1秒

  1. declare
  2.     type row_num_type is table of number index by simple_integer;
  3.     type row_text_type is table of varchar2(10) index by simple_integer;
  4.     row_num_tab row_num_type;
  5.     row_text_tab row_text_type;
  6.     v_total number;
  7.     v_start_time integer;
  8.     v_end_time integer;
  9. begin
  10.     for i in 1..1000 loop
  11.         row_num_tab(i) := i;
  12.         row_text_tab(i) := 'row'||i;
  13.     end loop;
  15.     v_start_time := dbms_utility.get_time;
  16.     dbms_output.put_line('v_start_time :'||v_start_time);
  18.     for i in 1..1000 loop
  19.         insert into test(row_num,row_text)
  20.         values (row_num_tab(i),row_text_tab(i));
  21.     end loop;
  23.     v_end_time    := dbms_utility.get_time;
  24.     dbms_output.put_line('v_end_time :'||v_end_time);
  26.     dbms_output.put_line('duration of the for loop '||(v_end_time - v_start_time));
  28.     select count(*) into v_total from test;
  29.     dbms_output.put_line(v_total||' rows insterted');
  31.     v_start_time := dbms_utility.get_time;
  32.     dbms_output.put_line('v_start_time :'||v_start_time);
  34.     forall i in 1..1000 
  35.         insert into test(row_num,row_text)
  36.         values (row_num_tab(i),row_text_tab(i));
  37.     commit;
  39.     v_end_time    := dbms_utility.get_time;
  40.     dbms_output.put_line('v_end_time :'||v_end_time);
  42.     dbms_output.put_line('duration of the forall statement '||(v_end_time - v_start_time));
  44.     select count(*) into v_total from test;
  45.     dbms_output.put_line(v_total||' rows insterted');
  47.     commit;
  48. end;
  49. /
  51. v_start_time :449982608
  52. v_end_time :449982611
  53. duration of the for loop 3
  54. 1000 rows insterted
  55. v_start_time :449982611
  56. v_end_time :449982611
  57. duration of the forall statement 0
  58. 2000 rows insterted



1.1 SAVE EXECPTIONS选项

  使用save exceptions选项能够实现:即使当对应的sql语句导致异常，forall语句仍旧能够继续执行。这些异常被存储在名为SQL%BULK_EXCEPTIONS的游标属性中。SQL%BULK_EXCEPTIONS游标属性是个记录集合，其中每个记录由两个字段组成：ERROR_INDEX和ERROR_CODE。ERROR_INDEX字段会存储发生异常的FORALL语句的迭代编号，ERROR_CODE会存储对应于抛出异常的oracle错误代码

  可以是用SQL%BULK_EXCEPTIONS.COUNT来检索FORALL语句执行过程中所发生的异常数量。注意，一贯不会保存单个的错误消息，但是可以使用SQLERRM函数进行查询。

  1. TRUNCATE TABLE TEST;
  2. DECLARE
  3.   -- Define collection types and variables
  4.   TYPE row_num_type IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
  5.   TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  6.   row_num_tab  row_num_type;
  7.   row_text_tab row_text_type;
  8.   -- Define user-defined exception and associated Oracle
  9.   -- error number with it
  10.   errors EXCEPTION;
  11.   PRAGMA EXCEPTION_INIT(errors, -24381);
  12. BEGIN
  13.   -- Populate collections
  14.   FOR i IN 1 .. 10 LOOP
  15.     row_num_tab(i) := i;
  16.     row_text_tab(i) := 'row ' || i;
  17.   END LOOP;
  18.   -- Modify 1, 5, and 7 elements of the V_ROW_TEXT collection
  19.   -- These rows will cause exception in the FORALL statement
  20.   row_text_tab(1) := RPAD(row_text_tab(1), 11, ' ');
  21.   row_text_tab(5) := RPAD(row_text_tab(5), 11, ' ');
  22.   row_text_tab(7) := RPAD(row_text_tab(7), 11, ' ');
  23.   -- Populate TEST table
  24.   FORALL i IN 1 .. 10 SAVE EXCEPTIONS /* 要是不写这个save exceptions就会直接抛出错误
  25.   ORA-12899: value too large for column "SCOTT"."TEST"."ROW_TEXT" (actual: 11, maximum: 10)*/
  26.     INSERT INTO test
  27.       (row_num, row_text)
  28.     VALUES
  29.       (row_num_tab(i), row_text_tab(i));
  30.   COMMIT;
  31. EXCEPTION
  32.   WHEN errors THEN
  33.     -- Display total number of exceptions encountered
  34.     DBMS_OUTPUT.PUT_LINE('There were ' || SQL%BULK_EXCEPTIONS.COUNT ||
  35.                          ' exceptions');
  36.     -- Display detailed exception information
  37.     FOR i in 1 .. SQL%BULK_EXCEPTIONS.COUNT LOOP
  38.       DBMS_OUTPUT.PUT_LINE('Record ' || SQL%BULK_EXCEPTIONS(i).error_index ||
  39.                            ' caused error ' || i || ': ' || SQL%BULK_EXCEPTIONS(i)
  40.                            .ERROR_CODE || ' ' ||
  41.                            SQLERRM(-SQL%BULK_EXCEPTIONS(i).ERROR_CODE));
  42.     END LOOP;
  43. END;
  44. /
  45. There were 3 exceptions
  46. Record 1 caused error 1: 12899 ORA-12899: value too large for column  (actual: , maximum: )
  47. Record 5 caused error 2: 12899 ORA-12899: value too large for column  (actual: , maximum: )
  48. Record 7 caused error 3: 12899 ORA-12899: value too large for column  (actual: , maximum: )


1.2 INDICES OF

正如前面所提到的那样，使用INDICES OF选项，可以循环处理稀疏的集合，回想一下，这种集合也许是嵌套表，或者联合数组。

引用的是下标

  1. declare
  2.   TYPE row_num_type IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
  3.   TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  4.   row_num_tab  row_num_type;
  5.   row_text_tab row_text_type;
  6.   v_total number;
  7. begin
  8.     FOR i IN 1 .. 10 LOOP
  9.         row_num_tab(i) := i;
  10.         row_text_tab(i) := 'row ' || i;
  11.       END LOOP;
  12.       row_num_tab.DELETE(1);row_text_tab.DELETE(1);
  13.       row_num_tab.DELETE(3);row_text_tab.DELETE(3);
  14.       row_num_tab.DELETE(5);row_text_tab.DELETE(5);
  15.       FORALL i in INDICES OF row_num_tab
  16.           insert into test(row_num,row_text)
  17.           values(row_num_tab(i),row_text_tab(i));
  18.       commit;
  19.       select count(*) into v_total from test;
  20.       dbms_output.put_line('There are '||v_total||' rows in the test table');
  21.  end;
  22.  /
  23. There are 7 rows in the test table
  25. PL/SQL procedure successfully completed.
  27. scott@ORCL>select * from test;
  29.    ROW_NUM ROW_TEXT
  30. ---------- ----------
  31.          2 row 2
  32.          4 row 4
  33.          6 row 6
  34.          7 row 7
  35.          8 row 8
  36.          9 row 9
  37.         10 row 10
  39. 7 rows selected.

为让当前嵌套变得稀疏，删除第1,3,5元素，这样的化，FORALL语句会迭代7次，第7行数据会添加到TEST表。下面的输出可以说明这一点

here are 7 rows in the test table


PL/SQL procedure successfully completed.


1.3 VALUES OF选项

VALUES OF用于一种不同的情况：绑定数组可以是稀疏数组，也可以不是，但我只想使用该数组中元素的一个子集。那么我就可以使用VALUES OF来指向我希望在DML操作中使用的值。

VALUES OF最关键的是他引用的是特定集合中单个元素的值

  1. SQL> declare
  2.   2    TYPE row_num_type IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
  3.   TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  4.   row_num_tab  row_num_type;
  5.   row_text_tab row_text_type;
  6. begin
  7. FOR i IN 1 .. 10 LOOP
  8.     row_num_tab(i) := i;
  9.     row_text_tab(i) := 'row ' || i;
  10.   END LOOP;
  11.  11  
  12.   row_num_tab.DELETE(1);row_text_tab.DELETE(1);
  13.   row_num_tab.DELETE(3);row_text_tab.DELETE(3);
  14.   row_num_tab.DELETE(5);row_text_tab.DELETE(5);
  15.  15  
  16.   FORALL i in values OF row_num_tab
  17.   insert into test(row_num,row_text)
  18.   values(row_num_tab(i),row_text_tab(i));
  19.   commit;
  20.  end;
  21.  21   /
  22.   TYPE row_num_type IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
  23.                        *
  24. ERROR at line 2:
  25. ORA-06550: line 2, column 24:
  26. PLS-00667: Element type of associative array should be pls_integer or binary_integer
  27. ORA-06550: line 16, column 15:
  28. PL/SQL: Statement ignored

values of后面跟的集合必须是pls_integer?

事实上values of使用的是联合数组，他必须使用PLS_INTEGER或BINARY_INTEGER进行索引

  1. create table test_exc(row_num number,row_text varchar2(50));
  3. DECLARE
  4.    -- Define collection types and variables
  5.    TYPE row_num_type  IS TABLE OF NUMBER       INDEX BY PLS_INTEGER;
  6.    TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  7.    TYPE exc_ind_type  IS TABLE OF PLS_INTEGER  INDEX BY PLS_INTEGER;
  8.    row_num_tab  row_num_type;
  9.    row_text_tab row_text_type;
  10.    exc_ind_tab  exc_ind_type;
  11.    -- Define user-defined exception and associated Oracle
  12.    -- error number with it
  13.    errors EXCEPTION;
  14.    PRAGMA EXCEPTION_INIT(errors, -24381);
  15. BEGIN
  16.    -- Populate collections
  17.    FOR i IN 1..10 LOOP
  18.       row_num_tab(i)  := i;
  19.       row_text_tab(i) := 'row '||i;
  20.    END LOOP;
  21.    -- Modify 1, 5, and 7 elements of the V_ROW_TEXT collection
  22.    -- These rows will cause exception in the FORALL statement
  23.    row_text_tab(1) := RPAD(row_text_tab(1), 11, ' ');
  24.    row_text_tab(5) := RPAD(row_text_tab(5), 11, ' ');
  25.    row_text_tab(7) := RPAD(row_text_tab(7), 11, ' ');
  26.    -- Populate TEST table
  27.    FORALL i IN 1..10 SAVE EXCEPTIONS
  28.       INSERT INTO test (row_num, row_text)
  29.       VALUES (row_num_tab(i), row_text_tab(i));
  30. COMMIT;
  31. EXCEPTION
  32.    WHEN errors THEN
  33.       -- Populate V_EXC_IND_TAB collection to be used in the VALUES
  34.       -- OF clause
  35.       FOR i in 1.. SQL%BULK_EXCEPTIONS.COUNT LOOP
  36.          exc_ind_tab(i) := SQL%BULK_EXCEPTIONS(i).error_index;
  37.       END LOOP;
  38.       -- Insert records that caused exceptions in the TEST_EXC
  39.       -- table
  40.       FORALL i in VALUES OF exc_ind_tab
  41.          INSERT INTO test_exc (row_num, row_text)
  42.          VALUES (row_num_tab(i), row_text_tab(i));
  43.    COMMIT;
  44. END;
  45. /
  47. scott@ORCL>select * from test;
  49.    ROW_NUM ROW_TEXT
  50. ---------- ----------
  51.          2 row 2
  52.          3 row 3
  53.          4 row 4
  54.          6 row 6
  55.          8 row 8
  56.          9 row 9
  57.         10 row 10
  59. 7 rows selected.
  60. test表插入的值应该没什么好解释的
  62. scott@ORCL>select * from test_exc;
  64.    ROW_NUM ROW_TEXT
  65. ---------- --------------------------------------------------
  66.          1 row 1
  67.          5 row 5
  68.          7 row 7
  70. values of引用的是集合的值,所以i是在exc_ind_tab的值中循环
  71.  exc_ind_tab(1) = 1
  72.  exc_ind_tab(2) = 5
  73.  exc_ind_tab(3) = 7
  74. 所以i in 1,5,7
  75. row_num_tab(1) = 1;row_text_tab(1) = row 1;
  76. row_num_tab(5) = 5;row_text_tab(5) = row 5;
  77. row_num_tab(7) = 7;row_text_tab(7) = row 7;
  82. 所以一个批量插入FORALL 异常模板可以是这样
  83. 1.输出错误信息
  84. 2.将错误信息插入err_log错日志表
  85. 3.将出错的行，插入text_exc表
  87. 创建一个err_log表
  88. create table err_log(id number,msg varchar2(500));
  89. DECLARE
  90.    errors EXCEPTION;
  91.    PRAGMA EXCEPTION_INIT(errors, -24381);
  93. BEGIN
  96. EXCEPTION
  97. 	WHEN errors THEN
  98. 		for i in 1..SQL%BULK_EXCEPTIONS.COUNT loop
  99.     		dbms_output.put_line('line '||SQL%BULK_EXCEPTIONS(i).INDEX_CODE||' has error. error is '||sqlerrm(-SQL%BULK_EXCEPTIONS(i).ERROR_CODE));
  100.     		insert into err_log values(SQL%BULK_EXCEPTIONS(i).INDEX_CODE,sqlerrm(-SQL%BULK_EXCEPTIONS(i).ERROR_CODE));
  101.     		exc_ind_tab(i) := SQL%BULK_EXCEPTIONS(i).error_index;
  102. 		end loop;
  103. 		commit;
  104. /* 把出问题的值插入test_exc表*/
  105. 		forall i in values of exc_ind_tab
  106. 			INSERT INTO test_exc (row_num, row_text) VALUES (row_num_tab(i), row_text_tab(i));
  107.    		COMMIT;
  108. END;
  109. /


我的实验


实验1：

INDICES OF不是稀疏的也可以

  1. declare
  2.   TYPE row_num_type IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
  3.   TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  4.   row_num_tab  row_num_type;
  5.   row_text_tab row_text_type;
  6. begin
  7.     FOR i IN 1 .. 10 LOOP
  8.         row_num_tab(i) := i;
  9.         row_text_tab(i) := 'row ' || i;
  10.       END LOOP;
  12.       row_num_tab.DELETE(1);row_text_tab.DELETE(1);
  13.       row_num_tab.DELETE(3);row_text_tab.DELETE(3);
  14.       row_num_tab.DELETE(5);row_text_tab.DELETE(5);
  16.       FORALL i in INDICES OF row_num_tab
  17.           insert into test(row_num,row_text)
  18.           values(row_num_tab(i),row_text_tab(i));
  19.       commit;
  20.  end;
  21.  /
  23.  declare
  24.   TYPE row_num_type IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
  25.   TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  26.   row_num_tab  row_num_type;
  27.   row_text_tab row_text_type;
  28. begin
  29.     FOR i IN 1 .. 10 LOOP
  30.         row_num_tab(i) := i;
  31.         row_text_tab(i) := 'row ' || i;
  32.       END LOOP;
  35.       FORALL i in INDICES OF row_num_tab
  36.           insert into test(row_num,row_text)
  37.           values(row_num_tab(i),row_text_tab(i));
  38.       commit;
  39.  end;
  40.  /
  43. PL/SQL procedure successfully completed.
  45. SQL> select * from test;
  47.    ROW_NUM ROW_TEXT
  48. ---------- ----------
  49.          1 row 1
  50.          2 row 2
  51.          3 row 3
  52.          4 row 4
  53.          5 row 5
  54.          6 row 6
  55.          7 row 7
  56.          8 row 8
  57.          9 row 9
  58.         10 row 10
  60. 10 rows selected.


实验2：

  1. declare
  2.   TYPE row_num_type IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
  3.   TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  4.   row_num_tab  row_num_type;
  5.   row_text_tab row_text_type;
  6. begin
  8.         row_num_tab(1) := 10;
  9.         row_text_tab(1) := 'row ' || 10;
  10.         row_num_tab(2) := 9;
  11.         row_text_tab(2) := 'row ' || 9;
  12.         row_num_tab(3) := 8;
  13.         row_text_tab(3) := 'row ' || 8;
  14.         row_num_tab(4) := 7;
  15.         row_text_tab(4) := 'row ' || 7;
  16.         row_num_tab(5) := 6;
  17.         row_text_tab(5) := 'row ' || 6;
  18.         row_num_tab(6) := 5;
  19.         row_text_tab(6) := 'row ' || 5;
  20.         row_num_tab(7) := 4;
  21.         row_text_tab(7) := 'row ' || 4;
  22.         row_num_tab(8) := 3;
  23.         row_text_tab(8) := 'row ' || 3;
  24.         row_num_tab(9) := 2;
  25.         row_text_tab(9) := 'row ' || 2;
  26.         row_num_tab(10) := 1;
  27.         row_text_tab(10) := 'row ' || 1;
  30.       FORALL i in INDICES OF row_num_tab
  31.           insert into test(row_num,row_text)
  32.           values(row_num_tab(i),row_text_tab(i));
  33.       commit;
  34.  end;
  35.  /
  37.  SQL> select * from test;
  39.    ROW_NUM ROW_TEXT
  40. ---------- ----------
  41.         10 row 10
  42.          9 row 9
  43.          8 row 8
  44.          7 row 7
  45.          6 row 6
  46.          5 row 5
  47.          4 row 4
  48.          3 row 3
  49.          2 row 2
  50.          1 row 1
  52. 10 rows selected.

FORALL i in INDICES OF row_num_tab

这个i是在 row_num_tab集合的下表中循环，下表就是1~10

否则如果是值得话，第一行就是row_text_tab(10)，显然不是这样


实验3：

  1. declare
  2.   TYPE row_num_type IS TABLE OF pls_integer INDEX BY PLS_INTEGER;
  3.   TYPE row_text_type IS TABLE OF VARCHAR2(11) INDEX BY PLS_INTEGER;
  4.   row_num_tab  row_num_type;
  5.   row_text_tab row_text_type;
  6. begin
  8.         row_num_tab(1) := 10;
  9.         row_text_tab(1) := 'row ' || 10;
  10.         row_num_tab(2) := 9;
  11.         row_text_tab(2) := 'row ' || 9;
  12.         row_num_tab(3) := 8;
  13.         row_text_tab(3) := 'row ' || 8;
  14.         row_num_tab(4) := 7;
  15.         row_text_tab(4) := 'row ' || 7;
  16.         row_num_tab(5) := 6;
  17.         row_text_tab(5) := 'row ' || 6;
  18.         row_num_tab(6) := 5;
  19.         row_text_tab(6) := 'row ' || 5;
  20.         row_num_tab(7) := 4;
  21.         row_text_tab(7) := 'row ' || 4;
  22.         row_num_tab(8) := 3;
  23.         row_text_tab(8) := 'row ' || 3;
  24.         row_num_tab(9) := 2;
  25.         row_text_tab(9) := 'row ' || 2;
  26.         row_num_tab(10) := 1;
  27.         row_text_tab(10) := 'row ' || 1;
  30.       FORALL i in values OF row_num_tab
  31.           insert into test(row_num,row_text)
  32.           values(row_num_tab(i),row_text_tab(i));
  33.       commit;
  34.  end;
  35.  /
  37.  PL/SQL procedure successfully completed.
  39. SQL> select * from test;
  41.    ROW_NUM ROW_TEXT
  42. ---------- ----------
  43.          1 row 1
  44.          2 row 2
  45.          3 row 3
  46.          4 row 4
  47.          5 row 5
  48.          6 row 6
  49.          7 row 7
  50.          8 row 8
  51.          9 row 9
  52.         10 row 10
  54. 10 rows selected.

FORALL i in values OF row_num_tab

这个i引用的是元素值所以他是在10~1中循环

而不是下标

第一行显然引用的是row_num_tab(10),row_text_tab(10)


而10是元素值

row_num_tab(1) := 10;

row_text_tab(1) := 'row ' || 10;






PL/SQL中的FORALL详解及简单测试（MySql）
VcyReact的博客
09-23 353
FORALL是PL/SQL中的一个循环结构，用于批量处理数据。它允许我们在单个语句中处理多行数据，而不是使用传统的基于游标的循环。FORALL的优点是它可以显著提高数据处理的效率，尤其是当我们需要处理大量数据时。statement;其中，index是一个循环索引变量，用于迭代执行语句。lower_bound和upper_bound分别是循环索引变量的起始值和结束值。SAVE EXCEPTIONS是一个可选的语句，用于在FORALL执行期间保存异常信息。
SAP-ABAP：FOR ALL ENTRIES IN 全面解析：从原理到最佳实践
最新发布
baidu_35680696的博客
06-11 1296
SAP-ABAP：最常用的 `FOR ALL ENTRIES IN` 深度解析
for all 用法小结
04-28
for all 用法小结详细谈了ORACLE 中的SQL 语句用法，绑定变量相关内容。值得一看。
plsql forall 详解
鱼丸丶粗面
01-22 7332
文章目录1 概述1.1 图示2 forall 的三种用法2.1 forall i in index_min .. index_max2.2 forall i in indices of collection2.3 forall i in values of collection3 forall 效率对比 1 概述 1. 作用：提高在 pl/sql 块中，处理 dml 语句的效率 2. "上下文切换": (1) 在 pl/sql 中，'pl/sql 块' 由 'pl/sql 引擎' 处理 (2
批量 SQL 之 FORALL 语句
热门推荐
乐沙弥的世界
05-05 1万+
对PL/SQL而言，任何的PL/SQL块或者子程序都是PL/SQL引擎来处理，而其中包含的SQL语句则由PL/SQL引擎发送SQL语句转交到SQL引擎来处理，SQL引擎处理完毕后向PL/SQL引擎返回数据。Pl/SQL与SQL引擎之间的通信则称之为上下文切换。过多的上下文切换将带来过量的性能负载。因此为减少性能的FORALL与BULK COLLECT的子句应运而生。即仅仅使用一次切换多次执行来降低
FORALL语句
cong31848的博客
02-22 238
FORALL语句的一个关键性改进，它可大大简化代码，并且对于那些要在PL/SQL程序中更新很多行数据的程序来说，它可显著提高其性能。1:用FORALL来增强DML的处理能力Oracle为Oracle8i中的P...
信息收集，子域名扫描工具oneforall
04-09
OneForAll是一款由Python编写的子域名收集工具，它可以帮助安全测试人员和渗透测试人员自动化地获取目标网站相关的子域名信息。OneForAll在设计时兼顾了准确性和速度，可以通过多种方式进行子域名的发现，例如DNS...
精选资源
OneForAll是一款功能强大的子域收集工具
09-01
在渗透测试中信息收集的重要性不言而喻，子域收集是信息收集中必不可少且非常重要的一环，目前...为了解决以上痛点，此项目应用而生，正如其名，我希望OneForAll是一款集百家之长，功能强大的全面快速子域收集终极神器
域名扫描-oneforall
m0_75208179的博客
08-31 2977
oneforall使用说明+附属便捷链接
精选资源
query-string-for-all:解析和字符串化 URL 查询字符串
08-04
$ npm install query-string-for-all 这是一个的分支，其中包含所有原始代码和 ES6 NPM 依赖项编译为 ES5，因此它可以在 IE 11 等较旧的浏览器中使用。 用法 const queryString = require ( 'query-string-for-all...
Oracle 中的 FORALL 语句
chenzebao2019的博客
08-18 4367
当要在 Oracle 中来批量 INSERT、UPDATE 和 DELETE 操作时，可以使用 FORALL 语句。 语法： Sql代码 --语法1： FORALL 下标变量(只能当作下标被引用) IN 下限..上限 sql 语句; --只允许一条 sql 语句 --语法2： FORALL 下标变量 IN INDICES OF(跳过没有赋值的元素，例如被 DELETE 的元素，NULL 也算值) 集合 [BETWEEN 下限 AND 上限] sql 语句;
FORALL的用法解析
weixin_34362875的博客
04-13 2260
当要在 Oracle 中之心批量 INSERT、UPDATE 和 DELETE 操作时，可以使用 FORALL 语句。语法：--语法1：FORALL下标变量(只能当作下标被引用)IN下限..上限 sql语句;--只允许一条sql语句--语法2：FORALL下标变量ININDICESOF(跳过没有赋值的元素，例如被...
forall
csdn1284934570的专栏
12-01 1024
Forall 下标变量 In 下限..上限   一条Sql语句; Forall 下标变量 In Indices Of 集合 [Between 下限 And 上限]     --跳过没有赋值的元素   一条sql语句; Forall 下标变量 In Values Of 集合                              --将集合值作为下标  值类型为pls_integer |
FORALL 用法小结
cargoj的博客
07-23 417
FORALL 用法小结： 作者：sonic 　　本文主要翻译、整理了ORACLE官方文档上有关FORALL的部份内容，不妥之处，还希望多和大家交流。 在发送语句到SQL引擎前，FORALL语句告知PL/SQL 引擎批挷定输入集合。尽管FORALL语句包含一个迭代(iteration)模式，它并不一是个FOR循环。其语法为： 　　FORALL index IN lower_bound..upper_...
FORALL用法小结
weixin_34184158的博客
03-09 178
本文主要翻译、整理了ORACLE官方文档上有关FORALL的部份内容，不妥之处，还希望多和大家交流。 在发送语句到SQL引擎前，FORALL语句告知PL/SQL 引擎批挷定输入集合。尽管FORALL语句包含一个迭代(iteration)模式，它并不一是个FOR循环。其语法为： 　　FORALL index IN lower_bound..upper_bound sql_s...
PL/SQL中BULK COLLECT FORALL与记录操作详解
"这篇内容主要讨论了PL/SQL中的集合操作BULK COLLECT和FORALL，以及记录（Record）这一复合数据类型的定义和使用方法。记录允许我们存储和操作多列数据，类似于数据库中的行，而BULK COLLECT和FORALL则提供了批量...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值