Oracle copie des données blob à partir d'une table à l'autre

J'ai une table (plus de 1.000.000 de lignes et 60 go de données) avec une colonne blob. Je veux déplacer la plupart des lignes (toutes les lignes) de la table à une autre. J'ai essayé insert into X select from y de commande mais c'est trop lent.

Quel est le moyen le plus rapide?

J'ai Oracle 10 ou 11.

Vous pourriez poser votre question sur la dba.stackexchange.com .
Pouvez-vous définir "trop lent"? Combien de temps faut-il pour copier 60 GO de données? Combien de temps avez-vous besoin de prendre? Quels sont les événements d'attente? N'60 GO comprennent la taille de la table segment? Ou le LOB segment? Ou la taille combinée des deux segments?
c'est en prendre plein la nuit (18:00-08:00) pour copier c'est normall?

InformationsquelleAutor ismail uzunok | 2011-08-23

3

utiliser /*+ ajouter */astuce pour passer archive log
lorsque vous utilisez l'indicateur oracle dosent créer arcive journaux
```
insert  /*+ append */into TABLE1
select  *
from    TABLE2
```
InformationsquelleAutor formuser66
1

ses trop tard pour proposer quelque chose, mais il peut aider avec des solutions ci-dessus, si votre nouvelle(la cible), table a des contraintes ou des indices ou des déclencheurs, puis essayez de supprimer/désactiver d'abord, puis les charger en vrac de données et, enfin, de créer et d'activer vos contraintes, les index et les déclencheurs du recul et d'analyser votre table d'index. ce gain de temps solution est proposé uniquement lorsque vous n'avez qu'à répliquer vos données en vrac une fois. comme lors de l'insertion de nouveaux enregistrements dans la table SGBD garantit les contraintes, les vérifications et des indices qui réduit la vitesse

InformationsquelleAutor rykhan

Ok, donc nous ne savons pas votre système de sorte qu'il est difficile de vous en dire beaucoup. Votre question dépend vraiment de votre environnement. Peu importe, voici quelques tests de toute façon pour montrer le temps et les ressources qu'il faut pour utiliser votre méthode par rapport à une autre méthode:

Disons que votre méthode est la méthode 1 et l'autre méthode est la méthode 2.

20:43:24 SQL> set autotrace on;
20:43:30 SQL> alter session set SQL_TRACE=TRUE;

Session altered.

20:43:39 SQL> --let's make sure we are reading from disk (for arguments sake)
20:43:45 SQL> alter system flush shared_pool;

System altered.

20:43:45 SQL> alter system flush buffer_cache;

System altered.

20:43:45 SQL> 
20:43:45 SQL> --clear my examples
20:43:45 SQL> drop table t;
drop table t
           *
ERROR at line 1:
ORA-00942: table or view does not exist


20:43:49 SQL> drop table u;
drop table u
           *
ERROR at line 1:
ORA-00942: table or view does not exist


20:43:49 SQL> 
20:43:49 SQL> --create table u - we will populate this with random numbers
20:43:49 SQL> create table u (y varchar2(4000));

Table created.

20:43:50 SQL> 
20:43:50 SQL> --insert 1 million rows of random numbers
20:43:50 SQL> insert into u
20:43:50   2  (select dbms_random.normal
20:43:50   3  from dual
20:43:50   4  CONNECT BY level <= 1000000);

1000000 rows created.


Execution Plan
----------------------------------------------------------
Plan hash value: 1236776825

------------------------------------------------------------------------------
| Id  | Operation                     | Name | Rows  | Cost (%CPU)| Time     |
------------------------------------------------------------------------------
|   0 | INSERT STATEMENT              |      |     1 |     2   (0)| 00:00:01 |
|   1 |  LOAD TABLE CONVENTIONAL      | U    |       |            |          |
|*  2 |   CONNECT BY WITHOUT FILTERING|      |       |            |          |
|   3 |    FAST DUAL                  |      |     1 |     2   (0)| 00:00:01 |
------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   2 - filter(LEVEL<=1000000)


Statistics
----------------------------------------------------------
       4175  recursive calls
      58051  db block gets
      13118  consistent gets
         47  physical reads
   54277624  redo size
        675  bytes sent via SQL*Net to client
        647  bytes received via SQL*Net from client
          3  SQL*Net roundtrips to/from client
         56  sorts (memory)
          0  sorts (disk)
    1000000  rows processed

20:44:21 SQL> 
20:44:21 SQL> --create table t - we will populate this from table u
20:44:21 SQL> create table t (x varchar2(4000));

Table created.

20:44:21 SQL> 
20:44:21 SQL> --let's make sure we are reading from disk (for arguments sake)
20:44:21 SQL> alter system flush shared_pool;

System altered.

20:44:21 SQL> alter system flush buffer_cache;

System altered.

20:44:26 SQL> 
20:44:26 SQL> --insert data from u to t (this is how you said you did this)
20:44:26 SQL> insert into t (select * from u);

1000000 rows created.


Execution Plan
----------------------------------------------------------
Plan hash value: 537870620

---------------------------------------------------------------------------------
| Id  | Operation                | Name | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------
|   0 | INSERT STATEMENT         |      |   997K|  1905M|  1750   (1)| 00:00:21 |
|   1 |  LOAD TABLE CONVENTIONAL | T    |       |       |            |          |
|   2 |   TABLE ACCESS FULL      | U    |   997K|  1905M|  1750   (1)| 00:00:21 |
---------------------------------------------------------------------------------

Note
-----
   - dynamic sampling used for this statement (level=2)


Statistics
----------------------------------------------------------
       5853  recursive calls
      58201  db block gets
      24213  consistent gets
       6551  physical reads
   54591764  redo size
        681  bytes sent via SQL*Net to client
        599  bytes received via SQL*Net from client
          3  SQL*Net roundtrips to/from client
         57  sorts (memory)
          0  sorts (disk)
    1000000  rows processed

20:44:41 SQL> 
20:44:41 SQL> 
20:44:41 SQL> --now let's start over with a different method
20:44:41 SQL> drop table t;

Table dropped.

20:44:48 SQL> drop table u;

Table dropped.

20:44:50 SQL> 
20:44:50 SQL> --create table u - we will populate this with random numbers
20:44:50 SQL> create table u (y varchar2(4000));

Table created.

20:44:51 SQL> 
20:44:51 SQL> --insert 1 million rows of random numbers
20:44:51 SQL> insert into u
20:44:51   2  (select dbms_random.normal
20:44:51   3  from dual
20:44:51   4  CONNECT BY level <= 1000000);

1000000 rows created.


Execution Plan
----------------------------------------------------------
Plan hash value: 1236776825

------------------------------------------------------------------------------
| Id  | Operation                     | Name | Rows  | Cost (%CPU)| Time     |
------------------------------------------------------------------------------
|   0 | INSERT STATEMENT              |      |     1 |     2   (0)| 00:00:01 |
|   1 |  LOAD TABLE CONVENTIONAL      | U    |       |            |          |
|*  2 |   CONNECT BY WITHOUT FILTERING|      |       |            |          |
|   3 |    FAST DUAL                  |      |     1 |     2   (0)| 00:00:01 |
------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   2 - filter(LEVEL<=1000000)


Statistics
----------------------------------------------------------
       2908  recursive calls
      58153  db block gets
      12831  consistent gets
         10  physical reads
   54284104  redo size
        683  bytes sent via SQL*Net to client
        647  bytes received via SQL*Net from client
          3  SQL*Net roundtrips to/from client
         31  sorts (memory)
          0  sorts (disk)
    1000000  rows processed

20:45:20 SQL> 
20:45:20 SQL> --let's make sure we are reading from disk (for arguments sake)
20:45:20 SQL> alter system flush shared_pool;

System altered.

20:45:20 SQL> alter system flush buffer_cache;

System altered.

20:45:25 SQL> 
20:45:25 SQL> --create table t using table u
20:45:25 SQL> create table t as (select * from u);

Table created.

20:45:36 SQL> 
20:45:36 SQL> drop table t;

Table dropped.

20:45:41 SQL> drop table u;

Table dropped.

20:45:41 SQL> 
20:45:41 SQL> commit;

Commit complete.

20:45:41 SQL> spool off

Ok, donc nous nous soucions les deux méthodes, nous avons testé c'est à dire

insert into t (select * from u);

qui nous fait un traçage réponse pour et

create table t as (select * from u);

que nous ne pouvons pas obtenir un traçage pour.

Heureusement j'ai aussi couru sql_trace et j'ai ramassé un TKprof de stats.

C'est ce que j'obtiens:
pour "insert into t (select * from u);":

********************************************************************************

SQL ID: bjdnhkhq8r6h4
Plan Hash: 537870620
insert into t (select * from u)



call     count       cpu    elapsed       disk      query    current        rows
------- ------  -------- ---------- ---------- ---------- ----------  ----------
Parse        1      0.00       0.03          2          2          0           0
Execute      1      1.74       7.67       6201      22538      58121     1000000
Fetch        0      0.00       0.00          0          0          0           0
------- ------  -------- ---------- ---------- ---------- ----------  ----------
total        2      1.74       7.71       6203      22540      58121     1000000

Misses in library cache during parse: 1
Misses in library cache during execute: 1
Optimizer mode: ALL_ROWS
Parsing user id: 91  

Rows     Row Source Operation
-------  ---------------------------------------------------
      0  LOAD TABLE CONVENTIONAL  (cr=0 pr=0 pw=0 time=0 us)
      1   TABLE ACCESS FULL U (cr=4 pr=5 pw=0 time=0 us cost=1750 size=1997891896 card=997948)

********************************************************************************

et pour "create table t (select * from u)", nous obtenons:

********************************************************************************

SQL ID: asawpwvdj1nbv
Plan Hash: 2321469388
create table t as (select * from u)


call     count       cpu    elapsed       disk      query    current        rows
------- ------  -------- ---------- ---------- ---------- ----------  ----------
Parse        1      0.00       0.03          2          2          1           0
Execute      1      0.90       2.68       6372      12823       8573     1000000
Fetch        0      0.00       0.00          0          0          0           0
------- ------  -------- ---------- ---------- ---------- ----------  ----------
total        2      0.90       2.71       6374      12825       8574     1000000

Misses in library cache during parse: 1
Optimizer mode: ALL_ROWS
Parsing user id: 91  

Rows     Row Source Operation
-------  ---------------------------------------------------
      0  LOAD AS SELECT  (cr=13400 pr=6382 pw=6370 time=0 us)
1000000   TABLE ACCESS FULL U (cr=12640 pr=6370 pw=0 time=349545 us cost=1750 size=2159012856 card=1078428)

********************************************************************************

Qu'est ce que cela nous dit?
bien:
-Méthode 2 a pris environ 65% moins de temps que la méthode 1 (ensemble de 5 secondes de moins de 1 million de lignes)
-Méthode 2 a pris environ 48% moins de temps PROCESSEUR que la méthode 1
-Un peu plus de disque a été analysée avec la méthode 2 de la méthode 1
-beaucoup moins de tampons ont été récupérées pour la méthode 2 que pour la méthode 1

espère que cela vous aide 🙂

InformationsquelleAutor Joel Slowik

Vous devez vous connecter pour publier un commentaire.