Oracle kopieren Sie die blob-Daten aus einer Tabelle in eine andere

Ich habe eine Tabelle (über 1.000.000 Zeilen und 60 GB Daten) mit einer blob-Spalte. Ich möchte zu bewegen, die meisten der Zeilen (nicht alle Spalten) der Tabelle zu einer anderen Tabelle. Ich habe versucht insert into X select from y Befehl, aber es ist zu langsam.

Was ist der Schnellste Weg?

Habe ich Oracle 10 oder 11.

Möchten Sie vielleicht zu stellen, deine Frage auf dba.stackexchange.com .
Können Sie definieren, "zu langsam"? Wie lange dauert es, bis kopieren 60 GB Daten? Wie lange brauchen Sie, es zu nehmen? Was sind die wait-events? Hat 60 GB umfassen, die Größe der Tabelle segment? Oder das LOB-segment? Oder die kombinierte Größe der beiden Segmente?
es ist voll Nacht (18:00-08:00) zu kopieren ist es normall?

InformationsquelleAutor ismail uzunok | 2011-08-23

3

verwenden /*+ append */Hinweis auf pass-archive-log
wenn Sie den Hinweis oracle dosent erstellen Archives-Protokolle
```
insert  /*+ append */into TABLE1
select  *
from    TABLE2
```
InformationsquelleAutor formuser66
1

es zu spät ist, etwas zu deuten, aber es kann helfen, mit den oben genannten Lösungen, wenn Ihr neues(Ziel -) Tabelle-Einschränkungen oder-Indizes oder Trigger hat, dann versuchen zu entfernen/deaktivieren Sie Sie zuerst, dann laden Sie Ihre bulk-Daten und schließlich erstellen/aktivieren von constraints, Indizes und Triggern zurück und analysieren Sie Ihre Tabelle Indizes. diese zeitsparende Lösung ist nur dann sinnvoll, wenn Sie nur zu replizieren, bulk-Daten einmal. wie beim einfügen von neuen Datensätzen in Tabelle DBMS sorgt für die Einschränkungen, Kontrollen und Indizes reduziert die Geschwindigkeit

InformationsquelleAutor rykhan

Ok, wir wissen also nicht, Ihr system so ist es schwer zu sagen, Sie viel. Ihre Frage hängt wirklich von Ihrer Umgebung. Unabhängig davon, hier sind einige tests sowieso, um zu zeigen, Zeit und Ressourcen, die es braucht, um die Verwendung Ihrer Methode gegenüber einer anderen Methode:

Lassen Sie uns sagen, dass Ihre Methode ist die Methode 1 und die andere Methode ist Methode 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, also kümmern wir uns um die beiden Methoden, die wir getestet, d.h.

insert into t (select * from u);

denen wir eine autotrace-Antwort und

create table t as (select * from u);

die wir nicht bekommen, eine autotrace.

Habe glücklicherweise lief auch sql_trace und ich nahm ein TKprof-stats.

Dies ist, was ich bekomme:
für "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)

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

sowie für "create table t as (select * from u)" erhalten wir:

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

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)

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

Also, was sagt uns das?
gut:
-Methode 2 dauerte etwa 65% insgesamt weniger Zeit als Methode 1 (ganze 5 Sekunden weniger für 1 Mio Zeilen)
-Methode 2 dauerte etwa 48% weniger CPU-Zeit insgesamt als Methode 1
-Etwas mehr Festplatte wurde analysiert mit Methode 2 Methode 1
-viel weniger Puffer abgerufen wurden, die für Methode 2 als für Methode 1

hoffe das hilft dir 🙂

InformationsquelleAutor Joel Slowik

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.