Az Oracle Data Integrator (ODI) rendszerében a “Execute on Hint” mezőben kiválasztható például a “Staging” opció azt jelenti, hogy az adott műveletet a staging területen kell végrehajtani. A staging terület egy köztes tároló, ahol az adatok ideiglenesen tárolódnak és feldolgozódnak, mielőtt a végső célhelyre kerülnének.
ODI hint beállítások és azok céljainak összefoglalása
Hint beállítás Leírás Előnyök
No Hint Nincs konkrét végrehajtási hely megadva. Az ODI maga dönti el, hol hajtja végre a műveletet. Rugalmasság, az ODI optimalizálási képességeinek kihasználása.
Source A műveletet a forrás rendszeren hajtja végre. Csökkenti az adatmozgatás szükségességét, gyorsabb végrehajtás, ha a forrás rendszer erőforrásai megfelelőek.
Staging A műveletet a staging területen hajtja végre. Köztes adatfeldolgozás, amely lehetővé teszi az adatok előkészítését és tisztítását, mielőtt a célrendszerbe kerülnek.
Target A műveletet a cél rendszeren hajtja végre. Az adatok közvetlenül a célrendszerben kerülnek feldolgozásra, ami csökkenti az adatmozgatás szükségességét a célrendszerbe.
Előnyök összefoglalása
No Hint: Az ODI optimalizálási képességeit kihasználva automatikusan kiválasztja a legjobb végrehajtási helyet.
Source: Csökkenti az adatmozgatás szükségességét, gyorsabb végrehajtás, ha a forrás rendszer erőforrásai megfelelőek.
Staging: Lehetővé teszi az adatok előkészítését és tisztítását, mielőtt a célrendszerbe kerülnek, ami javítja az adatminőséget.
Target: Az adatok közvetlenül a célrendszerben kerülnek feldolgozásra, ami csökkenti az adatmozgatás szükségességét a célrendszerbe.
Oracle adatbázis hint
Részletesebb információk az alábbi Oracle dokumentációkban találhatók:
Oracle Documentation 12c
book -> SQL Tuning Guide
Hintekről:
book -> SQL Language Reference -> 2. Basic Elements of Oracle SQL -> Comments -> Hints
Az eddigi pédákban szereplő OPERATION és OPTION műveletek és jelentésük a (PLAN_TABLE-ből)
------------------------------------------------------------------------------------------
TABLE ACCESS FULL -- a tábla összes sorának (blokkjának beolvasása)
HASH -- hash clusteren levő táblák elérése a hash függvény alapján
CLUSTER -- index clusteren levő táblák elérése
BY INDEX ROWID -- a tábla sorainak elérése a sorazonosítók alapján
BY USER ROWID -- a felhasználó által megadott sorazonosító alapján
BY GLOBAL INDEX ROWID -- globális partícionált indexből vett sorazonosítók alapján
BY LOCAL INDEX ROWID -- lokális partícionált indexből vett sorazonosítók alapján
PARTITION RANGE ALL -- összes partíció olvasása
PARTITION RANGE SINGLE -- egyetlen partíció olvasása
PARTITION RANGE ITERATOR -- több partíció olvasása
INLIST ITERATOR -- műveletek ismétlése
SORT AGGREGATE -- összesítés, csoportosítás (GROUP BY) nélkül
UNIQUE -- ismétlődések megszüntetése, rendezés alapú algoritmussal
GROUP BY -- rendezés alapú csoportosítás
JOIN -- előzetes rendezés a későbbi join-hoz
ORDER BY -- rendezés ORDER BY miatt
HASH UNIQUE -- ismétlődések megszüntetése, hash alapú algoritmus
HASH GROUP BY -- csoportok képzése hash alapú algoritmussal
UNION-ALL -- két sorhalmaz uniója
UNION -- unió ismétlődések megszűntetésével
MINUS -- két sorhalmaz különbsége
INTERSECTION -- metszet
CONCATENATION -- unió képzése két vagy több sorhalmazból
VIEW -- alkérdés sorainak előállítása
FILTER -- egy sorhalmaz szűrése
NESTED LOOPS -- join művelet NESTED LOOP algoritmussal
HASH JOIN -- hasítás alapú join algoritmus
HASH JOIN OUTER -- külső join
HASH JOIN ANTI -- baloldali antijoin (NOT EXISTS vagy NOT IN esetén)
HASH JOIN RIGHT -- jobboldali antijoin
HASH JOIN ANTI NA -- NULL aware, vagyis NULL is előfordulhat az antijoin során
HASH JOIN SEMI -- baloldali semijoin (EXISTS vagy IN esetén)
MERGE JOIN -- JOIN művelet, előzetesen rendezett sorhalmazok összefuttatásával
MERGE JOIN ANTI
MERGE JOIN SEMI
INDEX FULL SCAN -- teljes index végigolvasása növekvő sorrendben
INDEX FULL SCAN DESCENDING -- teljes index végigolvasása csökkenő sorrendben
INDEX FAST FULL SCAN -- teljes index végigolvasása, egyszerre több blokkot olvasva, nem sorrendben
INDEX RANGE SCAN -- intervallum keresés növekvő sorrendben (DESCENDING -> csökkenő)
INDEX UNIQUE SCAN -- egyedi érték keresés az indexben
INDEX SKIP SCAN -- több oszlopos index olvasása, az első oszlopok ismerete nélkül
AND-EQUAL -- két sorazonosító halmaz metszetét képezi
BITMAP INDEX SINGLE VALUE -- egyetlen bitvektor visszaadása
BITMAP INDEX RANGE SCAN -- több bitvektor visszaadása (több egyenlőséges feltétel)
BITMAP AND -- bitmapek közötti logikai művelet
BITMAP OR -- bitmapek közötti logikai művelet
BITMAP MERGE -- több bitvektor összefésülése egyetlen bitvektorrá
BITMAP CONVERSION TO ROWIDS -- bitvektor átalakítása sorazonosítókká
BITMAP CONVERSION FROM ROWIDS -- sorazonosítók átalakítása bitvektorrá
BITMAP CONVERSION COUNT -- ha csak a sorazonosítók számára van szükség, azok megszámolása
INLIST ITERATOR -- műveletek ciklusban
=================================================================================
Hintek (tippek) adása az optimalizálónak
---------------------------------------------------------------------------------
A hintek speciális megjegyzések, amelyek utasításokat adnak az optimalizálónak.
Mindig csak arra az utasitás blokkra vonatkoznak, amiben szerepelnek.
Az utasitás blokk a következők egyike lehet:
- Egyszerű SELECT, UPDATE, DELETE INSERT utasítás
- Komplex utasításban a külső utasitás vagy a SELECT (pl. INSERT /*+ hintek */ ... SELECT /*+ hintek */ ...)
- Összetett utasitás egyik része (pl. SELECT /*+ hintek */ ... UNION SELECT /*+ hintek*/ ... )
A hint csak közvetlenül az utasitás kulcsszava után jöhet megjegyzésben.
[SELECT|DELETE|UPDATE|INSERT] /*+ tipp_lista */ (a '+' előtt nincs szóköz !!! )
A hinteket szóköz választja el egymástól.
Ha hiba van a hint-ben az oracle figyelmen kívül hagyja, de nem jelez hibát.
Példák:
SELECT /*+ tipp lista */ * FROM emp WHERE ...
SELECT /*+ tipp lista */ * FROM emp WHERE deptno IN ( SELECT /*+ tipp lista */ deptno FROM ...)
INSERT /*+ tipp lista */ ... SELECT /*+ tipp lista */ ...
SELECT /*+ tipp lista */ ... UNION SELECT /*+ tipp lista */ ...
Fontos!
Ha minősített tábla szerepel a lekérdezésben akkor a sémanevet (nikovits) ne adjuk meg, használjunk aliast, pl.
SELECT /*+ full(c) */ ... FROM nikovits.cikk c ...
A legfontosabb hintek: (a teljes lista -> SQL Reference)
--------------------------------------------------------
ALL_ROWS
Költseg alapú optimalizalast valaszt es azon belul is a teljes lekerdezesre optimalizal.
FIRST_ROWS(n)
A legjobb valaszidőre optimalizál. Az lekérdezés első n sorát a lehető leggyorsabban
próbálja meg visszaadni. Ha nem adjuk meg n-et, akkor n=1-et tekinti.
FULL(tábla) vagy FULL(alias név)
Nem hasznal indexet, hanem full table scant.
CLUSTER(tábla)
Csak index clusteren lévő tábláknál van értelme.
HASH(tábla)
Csak hash clusteren lévő táblánál van értelme.
INDEX(tábla [indexlista])
A tablat index alapjan eri el. Ha nem adunk meg index nevet (vagy többet adunk meg)
akkor a legolcsóbb költségű indexet (a felsoroltakbol) használja.
INDEX_ASC(tábla [indexlista])
Növekvő sorrendben eri el az index bejegyzeseket.
INDEX_DESC(tábla [indexlista])
Megfordítja az alapértelmezett index bejárási sorrendet. Csökkenő sorrendben éri el
az index bejegyzéseket. (Illetve csökkenő indexnél növekvőben.)
INDEX_COMBINE(tabla [indexlista])
Bitmap indexek segítségével próbálja meg elérni az adatokat.
INDEX_FFS(tábla [indexlista])
Fast full index scan-re utasítja az optimalizálót a teljes tábla olvasás helyett.
INDEX_JOIN(tábla [indexlista])
Több index használatával és a sorazonosítók join-olásával érje el a táblát.
AND_EQUAL(tábla [indexlista])
Több index egyidejű használatával éri el a táblát, úgy, hogy az indexekből visszakapott
sorazonosítók metszetét képezi, majd ezekek követve olvassa be a sorokat.
NO_INDEX(tábla [indexlista])
A megadott indexek használatáról lebeszéli az optimalizálót.
NO_INDEX_FFS(tábla [indexlista])
A megadott indexek használatáról lebeszéli az optimalizálót.
NO_EXPAND
Ha a lekérdezésben OR vagy IN szerepel, akkor az optimalizáló hajlamos az egyes
esetek szerint külön-külön keresni (pl. index használatával). Ez a hint erről
beszéli le az optimalizálót.
USE_CONCAT
Az OR feltételekből uniót hoz létre, és így hajtja végre a lekérdezést.
LEADING(táblalista)
A megadott táblákkal kezdi a lekérdezés végrehajtását. (Hasonló az ORDERED-hez)
ORDERED
A táblákat abban a sorrendben fogja join-olni, ahogy azok a FROM után szerepelnek.
USE_HASH(táblalista)
A megadott táblákat hash join-nal join-olja a többi adatforráshoz.
NO_USE_HASH(táblalista)
Az előző ellentéte.
USE_NL(táblalista)
A megadott táblákat nested looppal join-olja a többi adatforráshoz. A megadott tábla
lesz a belső ciklus táblája.
NO_USE_NL(táblalista)
Az előző ellentéte
USE_MERGE(táblalista)
A megadott táblákat sort-merge-el join-olja a többi adatforráshoz.
NO_USE_MERGE(tablalista)
Az előző ellentéte.
NL_SJ, HASH_SJ, MERGE_SJ
NL_AJ, HASH_AJ, MERGE_AJ
A fentieket az alkérdésben lehet hintként megadni, és ekkor (ha lehetséges)
az oracle a megfelelő algoritmussal fogja a semi-joint, illetve anti-joint
elvégezni.
CURSOR_SHARING_EXACT
Arra utasítja az oracle-t, hogy semmiképpen ne cserélje le az utasítás elemzése
közben a literálokat bind változóra. Amúgy ezt lehet, hogy megtenné mivel ezzel
csökkenne az újraelemzések esélye. (lásd -> CURSOR_SHARING init paraméter)
DRIVING_SITE(tabla)
Elosztott lekérdezésnél van értelme. Arra utasítja az optimalizálót, hogy a megadott
tábla adatbázisában hajtsa végre a műveletet. (pl. join esetén távoli táblák között)
DYNAMIC_SAMPLING(tabla n) ahol 0 <= n <= 10
Menet közben próbál meg minta alapján döntéseket hozni a szelektivitásra vonatkozóan.
Minél nagyobb az n értéke, annál nagyobb mintát használ.
CACHE(tabla)
Hatására a tábla blokkjai a buffer cache LRU listajanak "friss" végére kerülnek.
Kis tábléknál hasznos, hogy sokáig lehessenek a buffer cache-ben.
NOCACHE(tabla)
Hatására a tábla blokkjai a buffer cache LRU listajanak "régi" végére kerülnek.
Alapertelmezes szerint is ide kerülnének FULL TABLE SCAN esetén.
APPEND
INSERT utasításban az utolsó blokk utáni területre teszi be az adatokat, és nem a blokkokban
meglévő szabad helyekre. Ezáltal gyorsabb lesz, de pazarlóbb.
NOAPPEND
A blokkok meglévő üres helyeit is kihasználja. (Illetve letiltja a párhuzamos insert-et)
MERGE(V)
V egy nézet neve. A nézet kiértékelésének egyik módja a nézet merge-elése a
fő lekérdezésbe. Erre utasítja az optimalizálót. Inline nézet esetén a hintet
beírhatjuk a nézet blokkjába (paraméter nélkül), vagy a fő lekérdezésbe (paraméterrel).
NO_MERGE(V)
Az előző ellentétére veszi rá az optimalizálót.
NO_QUERY_TRANSFORMATION
Az optimalizáló képes arra, hogy a lekérdezést valamilyen módon átalakítsa, és azt
hajtsa végre. Ilyen átalakítás például az OR-expansion, View-merging, Subquery-unnest,
Star-transformation, Materialized view-rewrite. A hint ezekről beszéli le az optimalizálót.
A fenti átalakítások mindegyike külön-külön is kérhető illetve letiltható egy hinttel.
USE_CONCAT - NO_EXPAND, MERGE - NO_MERGE, UNNEST - NO_UNNEST,
STAR_TRANSFORMATION - NO_STAR_TRANSFORMATION, REWRITE - NO_REWRITE
RULE
Szabály alapú optimalizálást használ, de ez a hint már nem javasolt.
-----------
Category Hint Available For Notes
ACC PATH AND_EQUAL /*+ CLUSTER ( tablespec ) */ -
ACC PATH CLUSTER /*+ FULL ( tablespec) */ Use on Clustered Tables only
ACC PATH FULL /*+ HASH ( tablespec ) */ Forces a table scan even if there are indexes.
ACC PATH HASH /*+ INDEX ( tablespec [TAL: indexspec ] ) */ Only to tables stored in a table cluster.
ACC PATH INDEX /*+ INDEX_ASC ( tablespec [TAL: indexspec ] ) */ If no indexspec is supplied, the optimizer will try to scan with each avail index.
ACC PATH INDEX_ASC /*+ INDEX_COMBINE ( tablespec [ indexspec [TAL: indexspec ]...] ) */ Essentially the same as INDEX.
ACC PATH INDEX_COMBINE /*+ INDEX_DESC ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Forces the optimizer to try multiple boolean combinations of indexes.
ACC PATH INDEX_DESC /*+ INDEX_DESC ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Essentially the same as INDEX.
ACC PATH INDEX_FFS /*+ INDEX_FFS ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Forces an index scan using specified index(es).
ACC PATH INDEX_JOIN /*+ INDEX_JOIN ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Indexes used should be based on columns in the where clause.
ACC PATH INDEX_SS /*+ INDEX_SS ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Useful with composite indexes where the first column is not used in the query, but others are.
ACC PATH INDEX_SS_ASC /*+ INDEX_SS_ASC ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Essentially the same as INDEX_SS.
ACC PATH INDEX_SS_DESC /*+ INDEX_SS_DESC ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Essentially the same as INDEX_SS.
ACC PATH NO_INDEX /*+ NO_INDEX ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Directs the Optimizer not to use specified index(es).
ACC PATH NO_INDEX_FFS /*+ NO_INDEX_FFS ( [ tablespec [ indexspec [TAL: indexspec ]... ] ) */ Directs the Optimizer to exclude a fast full scan of the specified index(es).
ACC PATH NO_INDEX_SS /*+ NO_INDEX_SS ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Directs the Optimizer to exclude a skip scan of the specified index(es).
ACC PATH ROWID - -
JOIN OP HASH_AJ - -
JOIN OP HASH_SJ - -
JOIN OP MERGE_AJ - -
JOIN OP MERGE_SJ - -
JOIN OP NL_AJ - -
JOIN OP NL_SJ - -
JOIN OP NO_USE_HASH /*+ NO_USE_HASH ( tablespec [TAL: tablespec ]... ) */ Negates the use of hash joins for the table specified.
JOIN OP NO_USE_MERGE /*+ NO_USE_MERGE ( tablespec [TAL: tablespec ]... ) */ Negates the use of sort-merge joins for the table specified.
JOIN OP NO_USE_NL /*+ NO_USE_NL ( tablespec [TAL: tablespec ]... ) */ Negates the use of nested-loop joins for the table specified.
JOIN OP USE_HASH /*+ USE_HASH ( tablespec [TAL: tablespec ]... ) */ Directive to join each table specified using a hash join.
JOIN OP USE_MERGE /*+ NO_USE_MERGE ( tablespec [TAL: tablespec ]... ) */ Directive to join each table specified using a sort--merge join.
JOIN OP USE_NL /*+ NO_USE_NL ( tablespec [TAL: tablespec ]... ) */ Directive to use a nested-loop join with the specified tables as the inner table.
JOIN OP USE_NL_WITH_INDEX /*+ USE_NL_WITH_INDEX ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Directive to use a nested-loop join with the specified table as the inner table using the index specified to satisfy at least one predicate.
JOIN ORDER LEADING /*+ LEADING ( tablespec ) */ Directive to join the tables in the order specified.
JOIN ORDER ORDERED /*+ ORDERED */ Directive to join tables in the order found in the FROM clause.
JOIN ORDER STAR - -
OPT APPROACH ALL_ROWS /*+ ALL_ROWS */ Indicates the goal is overall throughput.
OPT APPROACH CHOOSE - -
OPT APPROACH FIRST_ROWS /*+ FIRST_ROWS (integer) */ The goal is to retrieve the first row(s) as fast as possible.
OPT APPROACH RULE /*+ RULE */ Used to disable the COST based optimizer.
OTHER CACHE /*+ CACHE ( tablespec ) */ Should be used with the FULL hint. Places data in the most-recently used area of the buffer cache.
OTHER APPEND /*+ APPEND */ Directs the optimizer to INSERT data at the end of the existing table data using direct path I/O.
OTHER CURSOR_SHARING_EXACT /*+ CURSOR_SHARING_EXACT */ Directs the Optimizer to ignore previously parsed SQL that matches, but uses bind variables. Forces the SQL to be parsed unless an exact match is found.
OTHER DRIVING_SITE /*+ DRIVING_SITE ( tablespec ) */ Used when data is joined remotely via DBLink. Normally data at the remote site is returned to the local and joined. This hint directs the optimizer to send the local data to the remote site for resolution of the join.
OTHER DYNAMIC_SAMPLING /*+ DYNAMIC_SAMPLING ( [TAL: tablespec ] integer ) */ Only used in simple SELECT statements with a single table to approximate cardinality if there are no existing statistics on the table.
OTHER MODEL_MIN_ANALYSIS /*+ MODEL_MIN_ANALYSIS */ Used with spreadsheet and model analysis to minimize compile time.
OTHER NO_PUSH_PRED /*+ NO_PUSH_PRED [TAL: ( tablespec ) ] */ Opposite of PUSH_PRED, it directs the Optimizer not to try to push the predicate into the view.
OTHER NO_PUSH_SUBQ /*+ NO_PUSH_SUBQ ] */ Opposite of PUSH_SUBQ, it directs the Optimizer not to try and evaluate the subquery first.
OTHER NO_UNNEST /*+ NO_UNNEST */ Subqueries in the WHERE clause are considered nested. A subquery can be evaluated several times for multiple results in the “parent”. Unnesting evaluates the subquery once and merges the results with the body of the “parent”. This hint directs the Optimizer NOT to unnest.
OTHER NOAPPEND /*+ NOAPPEND */ Directs the Optimizer to utilize existing space in a table and negates parallel processing.
OTHER NOCACHE /*+ NOCACHE ( tablespec ) */ Should be used with the FULL hint. Places data in the least-recently used area of the buffer cache.
OTHER OPT_PARAM - -
OTHER ORDERED_PREDICATES - -
OTHER PUSH_PRED /*+ PUSH_PRED [TAL: ( tablespec ) ] */ Used when one of the tables in a join is an in-line view. Forces the predicate used to join the table and the view into the view.
OTHER PUSH_SUBQ /*+ PUSH_SUBQ * Used with an EXISTS or IN subselect to force evaluation of the subquery rather than the default behavior of the last.
OTHER UNNEST /*+ UNNEST */ Subqueries in the where clause are considered nested. A subquery could be evaluated several times for multiple results in the “parent”. Unnesting evaluates the subquery once and merges results with the body of the “parent”.
PARALLEL NO_PARALLEL /*+ NO_PARALLEL ( tablespec ) */ Directs the Optimizer not to parallel the specified table.
PARALLEL NO_PARALLEL_INDEX /*+ NO_PARALLEL_INDEX ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Directs the Optimizer not to parallel the specified index(es).
PARALLEL NO_PX_JOIN_FILTER /*+ NO_PX_JOIN_FILTER (tablespec) */ Directs the Optimizer not to try and join bitmap indexes in parallel.
PARALLEL NOPARALLEL /*+ NOPARALLEL ( tablespec ) */ Directs the Optimizer not to parallel the specified table.
PARALLEL NOPAARALLEL_INDEX /*+ NOPARALLEL_INDEX ( tablespec [ indexspec [TAL: indexspec ]... ] ) */ Directs the Optimizer not to parallel the specified index(es).
PARALLEL PARALLEL /*+ PARALLEL ( tablespec [ integer | TAL:DEFAULT ] ) */ Number specifies degrees of parallelism (how many processes).
PARALLEL PARALLEL_INDEX /*+ PARALLEL_INDEX ( tablespec [ indexspec [TAL: indexspec ]... ] integer | DEFAULT ) */ Number specifies degree of parallelism (how many processes).
PARALLEL PQ_DISTRIBUTE /*+ PQ_DISTRIBUTE( tablespec outer_distribution inner_distribution ) */ Used in parallel join operations to indicate how inner and outer tables of the joins should be processed. The values of the distributions are HASH, BROADCAST, PARTITION, and NONE. Only six combinations table distributions are valid.
PARALLEL PX_JOIN_FILTER /*+ PX_JOIN_FILTER (tablespec) */ Directs the Optimizer to try and join bitmap indexes in parallel.
QUERY TRANS EXPAND_GSET_TO_UNION /*+ EXPAND_GSET_TO_UNION */ Performs transformations on queries that have GROUP BY into Unions.
PARALLEL FACT /*+ FACT ( tablespec ) */ In the context of STAR transformation, this table should be considered a FACT table (as opposed to a DIMENSION).
PARALLEL MERGE /*+ MERGE ( [ view | tablespec ) */ Use with either an in-line view that has a Group by or Distinct in it as a joined table, or with the use of IN subquery to “merge” the “view” into the body of the rest of the query.
PARALLEL NO_EXPAND /*+ NO_EXPAND */ Used when OR condition (including IN lists) is present in the predicate to not consider transformation to compound query.
PARALLEL NO_FACT /*+ NO_FACT ( tablespec ) */ In the context of STAR transformation this table should not be considered a FACT table.
PARALLEL NO_MERGE /*+ NO_MERGE [ ( [ view | TAL:tablespec ) ] */ Directs the Optimizer not to “merge” the view into the query.
PARALLEL NO_QUERY_TRANSFORMATION /*+ NO_QUERY_TRANSFORMATION */ Directs the Optimizer not to transform OR, in-lists, in-line views, and subqueries. Try it whenever any of these conditions are present.
PARALLEL NO_REWRITE /*+ NO_REWRITE */ Directs the Optimizer not to use a Materialized View, even if one is available.
PARALLEL NO_STAR_TRANSFORMATION /*+ NO_STAR_TRANSFORMATION */ Directs the Optimizer not to try a Star Transformation.
PARALLEL NO_XML_QUERY_REWRITE /*+ NO_XML_QUERY_REWRITE */ Use only if the query is using XML functionality.
PARALLEL NO_XMLINDEX_REWRITE /*+ NO_XMLINDEX_REWRITE */ Use only if the query is using XML functionality.
PARALLEL NOFACT /*+ NOFACT ( tablespec ) */ In the context of STAR transformation, this table should not be considered a FACT table.
PARALLEL NOREWRITE /*+ NOREWRITE Directs the Optimizer not to use a Materialized View, even if one is available.
PARALLEL REWRITE /*+ REWRITE Directs the Optimizer to use a Materialized View instead of the underlying tables. Specify REWRITE without additional parameters. Oracle will determine if it can us a Materialized View or not.
[ ( view [TAL: view ]... ) ] */
PARALLEL STAR_TRANSFORMATION /*+ STAR_TRANSFORMATION */ Directs the Optimizer to try Star Transformation. Only try with a 3 table or more join.
PARALLEL USE_CONCAT /*+ USE_CONCAT */ Used when the OR condition (including IN lists) is present in the predicate to transform the query into a compound UNION ALL.
REAL TIME MONITOR /*+ MONITOR */ Effective only if STATSTICS_LEVEL initialization parameter is either set to ALL or TYPICAL and CONTROL_MANAGEMENT_
PACK_ACCESS is set to DIAGNOSTIC+TUNING. Turns on features of the Oracle Database Tuning Pack.
REAL TIME NO_MONITOR /*+ NO_MONITOR */ See MONITOR hint.
-----
SELECT /*+ ALL_ROWS */ employee_id, last_name, salary, job_id
FROM employees
WHERE employee_id = 7566;
----
SELECT /*+ STAR_TRANSFORMATION */ s.time_id, s.prod_id, s.channel_id
FROM sales s, times t, products p, channels c
WHERE s.time_id = t.time_id
AND s.prod_id = p.prod_id
AND s.channel_id = c.channel_id
AND c.channel_desc = 'Tele Sales';
----
SELECT /*+ LEADING(e j) */ *
FROM employees e, departments d, job_history j
WHERE e.department_id = d.department_id
AND e.hire_date = j.start_date;
--------------------------------
ALTER SESSION ENABLE PARALLEL DML or the hint enable_parallel_dml
..
INSERT /*+ APPEND PARALLEL(16) */ INTO ITEM
(
)
SELECT a
FROM GTT_LINE p, GTT_LINE_XY r
Where <condition>
===
NSERT /*+ APPEND PARALLEL(16) enable_parallel_dml */ INTO ITEM
(
)
SELECT a
FROM GTT_LINE p, GTT_LINE_XY r
Where <condition>
---
A DOP (jelen esetben a párhuzamosság foka) kiválasztásával kapcsolatban több tényezőt kell figyelembe vennie
1. Mi az értéke a parallel_max_servers
2. A parallel_degree_policy = manuális vagy automatikus?
3. Ha auto, akkor mire van beállítva a parallel_degree_limit?
4. A DBA felülírta a tippeket az optimizer_ignore_parallel_hints segítségével?
5. Hány CPU mag van azon a gazdagépen, amely(ek)en az adatbázis fel van szerelve?
6. Hány másik munkamenet hány párhuzamos slave-t használ egyszerre?
7. Van olyan DBRM (Resource Manager) szabály, amely korlátozza a DOP-t az Ön fogyasztói csoportjában?
8. Mekkora táblák vannak, amelyeket átvizsgál, vagy amelyekhez csatlakozik?
---
With SELECT statement:
SELECT /*+ parallel(4) */ ...
With INSERT statement:
INSERT /*+ parallel(8) */ INTO ...
With CREATE INDEX statement:
CREATE /*+ parallel(2) */ INDEX ...
With UPDATE statement:
UPDATE /*+ parallel(6) */ ...
With DELETE statement:
DELETE /*+ parallel(8) */ ...
With MERGE statement:
MERGE /*+ parallel(4) */ INTO ...
With ALTER TABLE statement:
ALTER /*+ parallel(8) */ TABLE ...
With ANALYZE statement:
ANALYZE /*+ parallel(4) */ ...
--------------------------------
DBMS_PROFILER, DBMS_JOB, UTL_FILE
----- párhuzamos szálas futások lekérdezések
SELECT sql_id, status, rows_processed, time_remaining,plan_hash_value, sql_text,degree, instances,executions, rows_processed, elapsed_time
FROM V$SQL
WHERE parallel = 'YES'
ORDER BY time_remaining;
---
SELECT sql_id, executions, rows_processed, elapsed_time, begin_interval_time,plan_hash_value, operation, options
FROM dba_hist_sqlstat
WHERE parallel = 'YES'
AND begin_interval_time BETWEEN 'start_time' AND 'end_time'
ORDER BY begin_interval_time;
----
SELECT sql_id, executions, rows_processed, elapsed_time
FROM gv$sql_monitor
WHERE parallel = 'YES'
AND begin_interval_time BETWEEN 'start_time' AND 'end_time'
ORDER BY begin_interval_time;
To check the parallel execution status of the query:
SELECT * FROM v$session_longops WHERE opname = 'parallel query';
To check the parallel execution statistics of the query:
SELECT * FROM v$px_session;
To check the number of parallel slaves used by the query:
SELECT * FROM v$px_process;
To check the parallel execution details of the query:
SELECT * FROM v$px_session_info;
To check the parallel execution statistics for a specific parallel query operation:
SELECT * FROM v$px_operation_stats;
To check the parallel execution statistics for a specific parallel query coordinator process:
SELECT * FROM v$px_coordinator_stats;
To check the parallel execution statistics for a specific parallel query execution plan:
SELECT * FROM v$px_execution_plan;
---
Below is a more sophisticated script that combines several of the queries I provided earlier to monitor the performance of a query that is using the parallel hint:
WITH parallel_info AS (
SELECT
sid, serial#,
opname,
target,
sofar,
totalwork,
time_remaining,
round(sofar/totalwork*100,2) as "Percent Complete"
FROM v$session_longops
WHERE opname = 'parallel query'
), parallel_stats AS (
SELECT
sid,
px_servers_executions,
px_servers_status,
round(elapsed_time/1000000) as elapsed_time_secs
FROM v$px_session
), parallel_slaves AS (
SELECT
sid,
px_process_pid,
px_process_status
FROM v$px_process
)
SELECT
parallel_info.*,
parallel_stats.*,
parallel_slaves.*
FROM parallel_info
JOIN parallel_stats
ON parallel_info.sid = parallel_stats.sid
JOIN parallel_slaves
ON parallel_stats.sid = parallel_slaves.sid
ORDER BY parallel_info.sid;
/*
oszlopdefiníció, amellyel sok DBA már tisztában van;
SID, SERIAL#: Ezek az oszlopok a párhuzamos lekérdezés munkamenetét és sorozatszámát jelzik.
OPNAME: A párhuzamos lekérdezés által végrehajtott művelet, amely ebben az esetben „párhuzamos lekérdezés”.
CÉL: A párhuzamos lekérdezés által feldolgozott sorok becsült száma.
SOFAR: Az eddig feldolgozott sorok száma.
TOTALWORK: A párhuzamos lekérdezés által feldolgozott sorok teljes száma.
TIME_REMAINING: A párhuzamos lekérdezés befejezéséig hátralévő becsült idő.
PERCENT_COMPLETE: Az eddig elvégzett összes munka százalékos aránya.
PX_SERVERS_EXECUTIONS: A lekérdezést végrehajtó párhuzamos szerverek száma.
PX_SERVERS_STATUS: A lekérdezést végrehajtó párhuzamos szerverek állapota.
ELAPSED_TIME_SECS: A párhuzamos lekérdezés eltelt ideje másodpercben
PX_PROCESS_PID: A párhuzamos szerver folyamatazonosítója.
PX_PROCESS_STATUS: A párhuzamos szerver állapota (ACTIVE, IDLE stb.).
*/
----
/*+ parallel(4) */ azt jelenti, hogy megkéred az optimalizálót, hogy a 4-et használja a párhuzamosság mértékeként.
/*+ Parallel 4 */ azt jelenti, hogy megkéred az optimalizálót a párhuzamos végrehajtás használatára,
de nem adod meg a fokozatot, hanem hagyod, hogy az adatbázis automatikusan döntse el a párhuzamosság mértékét.
A 4 nem része a tippnek, ez egyszerűen egy megjegyzés, bármi lehet benne.
----
Parallel Process Details including Master/Slave relationships
set lines 200
set pages 100
col username format a10
col qcslave format a10
col slaveset format a8
col program format a30
col sid format a5
col slvinst format a7
col state format a8
col waitevent format a30
col qcsid format a5
col qcinst format a6
col reqdop format 999
col actdop format 999
col secelapsed format 999,999
SELECT DECODE(px.qcinst_id,NULL,username, ' - '||LOWER(SUBSTR(pp.SERVER_NAME,LENGTH(pp.SERVER_NAME)-4,4) ) ) USERNAME,
DECODE(px.qcinst_id,NULL, 'QC', '(Slave)') "QCSLAVE" ,
TO_CHAR( px.server_set) SLAVESET,
s.program PROGRAM,
TO_CHAR(s.SID) SID,
TO_CHAR(px.inst_id) SLVINST,
DECODE(sw.state,'WAITING', 'WAIT', 'NOT WAIT' ) STATE,
CASE sw.state WHEN 'WAITING' THEN SUBSTR(sw.event,1,30) ELSE NULL END WAITEVENT ,
DECODE(px.qcinst_id, NULL ,TO_CHAR(s.SID) ,px.qcsid) QCSID,
TO_CHAR(px.qcinst_id) QCINST,
px.req_degree REQDOP,
px.DEGREE ACTDOP,
DECODE(px.server_set,'',s.last_call_et,'') SECELAPSED
FROM gv$px_session px,
gv$session s,
gv$px_process pp,
gv$session_wait sw
WHERE px.SID=s.SID (+)
AND px.serial#=s.serial#(+)
AND px.inst_id = s.inst_id(+)
AND px.SID = pp.SID (+)
AND px.serial#=pp.serial#(+)
AND sw.SID = s.SID
AND sw.inst_id = s.inst_id
ORDER BY DECODE(px.QCINST_ID, NULL, px.INST_ID, px.QCINST_ID),
px.QCSID,
DECODE(px.SERVER_GROUP, NULL, 0, px.SERVER_GROUP),
px.SERVER_SET,
px.INST_ID
----
SELECT name, value FROM v$parameter WHERE name IN ('parallel_max_servers', 'parallel_execution_enabled');
----
INSERT INTO /*+APPEND */ ITEM
(
)
SELECT /*+ PARALLEL(p, 8) PARALLEL(r, 16) */ a
FROM GTT_LINE p, GTT_LINE_XY r
Where <condition>
UNION
SELECT /*+ PARALLEL(p, 8) PARALLEL(r, 16) */ a
FROM GTT_LINE p, GTT_LINE_XY r
Where <condition>
----
SELECT /*+ PARALLEL(emp,8) */ first_name, last_name FROM employee emp;
----
--monitor
select * from v$session
----
select dbms_metadata.get_ddl( object_type, object_name, owner )
from dba_objects where lower(object_name) like lower('table_x_purge_data')
----
SQL> CREATE TABLE "TABLE_X"
2 ( "OBJID" NUMBER,
3 "DEV" NUMBER,
4 "X_ACCOUNTID" VARCHAR2(40),
5 "S_X_ACCOUNTID" VARCHAR2(40),
6 "X_DATE" DATE,
7 "X_USERID" VARCHAR2(20),
8 "X_SITED" VARCHAR2(80),
9 "X_ACTIVITY" VARCHAR2(40),
10 "X_SCREEN_NAME" VARCHAR2(60),
11 "X_DATA_NAME_1" VARCHAR2(60),
12 "X_VALUE_NAME_1" VARCHAR2(255),
13 "X_DATA_NAME_2" VARCHAR2(60),
14 "X_VALUE_NAME_2" VARCHAR2(60),
15 "X_DATA_NAME_3" VARCHAR2(60),
16 "X_VALUE_NAME_3" VARCHAR2(60),
17 "S_X_USERID" VARCHAR2(20),
18 "X_CLIENT_HOST" VARCHAR2(60),
19 "X_SERVER_HOST" VARCHAR2(60)
20 ) PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255
21 PARTITION BY RANGE ("X_DATE") INTERVAL (NUMTOYMINTERVAL(1,'MONTH'))
22 (
23 PARTITION "WEEK_01_2016" VALUES LESS THAN (date '2016-01-04') SEGMENT CREATION IMMEDIATE,
24 PARTITION "WEEK_02_2016" VALUES LESS THAN (date '2016-01-11') SEGMENT CREATION IMMEDIATE,
25 PARTITION "WEEK_03_2016" VALUES LESS THAN (date '2016-01-18') SEGMENT CREATION IMMEDIATE,
26 PARTITION "WEEK_04_2016" VALUES LESS THAN (date '2016-01-25') SEGMENT CREATION IMMEDIATE,
27 PARTITION "WEEK_05_2016" VALUES LESS THAN (date '2016-02-01') SEGMENT CREATION IMMEDIATE
----------------------
SQL> ALTER SESSION SET parallel_degree_policy = manual;
SQL> ALTER SESSION SET parallel_degree_limit = 3;
SQL> ALTER SESSION SET parallel_min_time_threshold = 42;
SQL> EXPLAIN PLAN FOR SELECT /*+ parallel(default) */ count(*) FROM t;
SQL> SELECT * FROM table(dbms_xplan.display(format=>'basic +note'));
show parameter cpu
Megjegyzések
Megjegyzés küldése