Listes des hints courants

La lecture d'un rapport AWR (Automatic Workload Repository)

Regroupement avec GROUP BY

Substr et opérations sur les chînes.

Insérer un CLOB par sql*Loader

Les directories : manipulation de fichiers

Le bind peeking

Les histogrammes associés aux statistiques

Les secrets de la fonction DECODE

Les triggers

Plans d'exécution stockés

Aperçu des transactions autonomes

CBO : les plans d'exécution selon la volumétrie cible

Reprise de données : exemples simples

Clés primaires et étrangères : mettre en place ses contraintes d'intégrité

L'instruction MERGE ou l'insertion choisie

DBlink : interroger une base distante

Pourquoi mon index n'est pas utilisé ?

Les index bitmap

Les bind variables pour les requêtes courantes

Injection et traitements de masse

Créer un index de fonction

Vidage de cache

Utilisation de rownum et rowid

Les exceptions SQL oracle

Des lignes aux colonnes, un PIVOT suffit pour la 11g ; DECODE en attendant

Migration de modèles avec vues et synonymes

La clause WITH à la rescousse des sous requêtes

Comparer l'exécution d'une requête avec 2 index différents

La table DUAL pour développer

Tablespaces, datafiles et filesystem, comprendre le stockage

Modifier des paramètres, arrêter et redémarrer une base oracle.

Comprendre à quoi sert le listener et test avec tnsping

Interaction shell Unix / sqlplus Oracle

Gérer l'auto-increment sous Oracle

Le dictionnaire de données : premiers pas

Les LOB pour contourner les limites de LONG

Hint oracle et choix du plan d'exécution

Les types SQL et les types PL

Migration des LOB dans un tablespace dédié

SQL générant du SQL

Industrialisation des scripts SQL

CREATE OR REPLACE ... oui mais pour les tables ?

Les vues

Migration des index dans un tablespace dédié

Les colonnes virtuelles en 11g

Monter des données dans le cache Oracle

Index

La jointure : sélection sur plusieurs tables

XML et Oracle

Les statistiques Oracle

Import avec les contraintes : ordonner les insert

Les tables partitionnées

Fonction Oracle à partir d'une procédure java

Exporter la structure d'une base

Améliorer les performances d'une vue

Les index B-tree

Listes des hints courants


/*+ ALL_ROWS */

Indique que le coût doit être minimum pour évaluer l'ensemble des lignes retourner (indépendemment du fetch)


/*+ CHOOSE */

Active le mode CBO (Cost Based Optimizer) pour exécuter la requête, indépendemment du paramètre optimizer_mode (surcharge)statement


/*+ FIRST_ROWS */

Indique à Oracle d'utiliser le CBO afin de ramener la première ligne le plus rapidement, sans s'occuper de lignes suivantes.
En cas de group by, order by, count, ... ce hint n'a aucune pertinence.


/*+ RULE */

Utilise, pour la requête, le mode RULE, c'est à dire que les statistiques ne sont pas prises en compte (surcharge le paramètre optimizer_mode)


/*+ AND_EQUAL(table index) */

Explicite l'utilisation du plan d'exécution qui évalue les conditions unitairement sur les colonnes.



/*+ CLUSTER(table) */

Explicite un cluster scan sur la table en paramètre


/*+ FULL(table) */

Explicite l'utilisation d'un full table scan (pas d'index) sur la table


/*+ HASH(table) */

Définit l'utilisation d'une comparaison par hash (jointure)


/*+ HASH_AJ(table) */

Utilise une comparaison par hash dans une requête contenant NOT IN



/*+ HASH_SJ (table) */

Transforms a NOT IN sub query INTO a hash anti-join TO access the
specified TABLE

/*+ INDEX(table index) */

Force l'utilisation de l'index pour le parcours de la table



/*+ INDEX_ASC(table index) */

Explicitly chooses an ascending-RANGE INDEX scan FOR the specified
TABLE

/*+ INDEX_COMBINE(table index) */

IF no indexes are given AS arguments FOR the INDEX_COMBINE hint, the
optimizer uses whatever BOOLEAN combination OF bitmap indexes has the
best cost estimate. IF particular indexes are given AS arguments, the
optimizer tries TO USE some BOOLEAN combination OF those particular
bitmap indexes.

/*+ INDEX_DESC(table index) */

Explicitly chooses a descending-RANGE INDEX scan FOR the specified TABLE

/*+ INDEX_FFS(table index) */

Causes a fast full INDEX scan TO be performed rather than a full
TABLE scan

/*+ MERGE_AJ (table) */

Transforms a NOT IN sub query INTO a merge anti-join TO access the
specified TABLE

/*+ MERGE_SJ (table) */

Transforms a correlated EXISTS sub query INTO a merge semi-join TO
access the specified TABLE

/*+ ROWID(table) */

Explicitly chooses a TABLE scan BY ROWID FOR the specified TABLE

/*+ USE_CONCAT */

Forces combined OR conditions IN the WHERE clause OF a query TO be
transformed INTO a compound query using the

UNION ALL SET OPERATOR

/*+ ORDERED */

Causes Oracle TO join tables IN the ORDER IN which they appear IN
the FROM clause

/*+ STAR */

Forces the large TABLE TO be joined using a nested-LOOP join ON the INDEX

/*+ DRIVING_SITE (table) */

Forces query execution TO be done AT a different site FROM that selected
BY Oracle

/*+ USE_HASH (table) */

Causes Oracle TO join each specified TABLE WITH another ROW source
WITH a hash join

/*+ USE_MERGE (table) */

Causes Oracle TO join each specified TABLE WITH another ROW source
WITH a sort-merge join

/*+ USE_NL (table) */

Causes Oracle TO join each specified TABLE TO another ROW source
WITH a nested-loops join using the specified TABLE AS the inner TABLE

/*+ APPEND */ , /*+ NOAPPEND */

Specifies that data IS simply appended (OR NOT) TO a TABLE; existing
free SPACE IS NOT used. USE these hints only following the INSERT keyword.

/*+ NOPARALLEL(table) */

Disables parallel scanning OF a TABLE, even IF the TABLE was created
WITH a PARALLEL clause

/*+ PARALLEL(table, instances) */

This allows you TO specify the desired NUMBER OF concurrent slave processes
that can be used FOR the operation. DELETE, INSERT, AND UPDATE operations
are considered FOR parallelization only IF the session IS IN a PARALLEL DML
enabled MODE. (USE ALTER SESSION PARALLEL DML TO enter this MODE.)

/*+ PARALLEL_INDEX */

Allows you TO parallelize fast full INDEX scan FOR partitioned AND
non-partitioned indexes that have the PARALLEL attribute

/*+ NOPARALLEL_INDEX */

Overrides a PARALLEL attribute setting ON an INDEX

/*+ CACHE */

Specifies that the blocks retrieved FOR the TABLE IN the hint are placed
AT the most recently used END OF the LRU list IN the buffer cache WHEN a
full TABLE scan IS performed

/*+ NOCACHE */

Specifies that the blocks retrieved FOR this TABLE are placed AT the
LEAST recently used END OF the LRU list IN the buffer cache WHEN a full
TABLE scan IS performed

/*+ MERGE (table) */

Causes Oracle TO evaluate complex views OR sub queries before the
surrounding query

/*+ NO_MERGE (table) */

Causes Oracle NOT TO merge mergeable views

/*+ PUSH_JOIN_PRED (table) */

Causes the optimizer TO evaluate, ON a cost basis, whether OR NOT TO push
individual join predicates INTO the VIEW

/*+ NO_PUSH_JOIN_PRED (table) */

Prevents pushing OF a join predicate INTO the VIEW

/*+ PUSH_SUBQ */

Causes non merged sub queries TO be evaluated AT the earliest possible
place IN the execution plan

/*+ STAR_TRANSFORMATION */

Makes the optimizer USE the best plan IN which the transformation has been used.

[ ... ] Lire la suite



Vous n'avez pas trouver réponse à votre question ? Préciser votre recherche :

Catégories