Performance OCI vs SQL Loader

[falcon74]

Bonjour,

J'ai besoin dans mon travail de regler des problèmes de performance d'injection Oracle pour l'un de nos produits.

J'ai vu que l'api OCI permettait d'injecter en mode bulk et je suis en train de me demander si les performances de ce mode seront comparable à SQL Loader ou non ?

En gros, est-ce que je peux integrer l'injection de masse dans mon programme ou est-ce qu'il vaut mieux faire des appels à SQL Loader ?

Merci d'avance.

Falcon

[Vincent Rogier]

salut,

SQL*Loader est codé avec OCI et peut être utilisé en mode DIRECT PATH qui comme son nom l'indique utilise l'API direct path de OCI.

SQL*Loader est un très outil éprouvé.

Tu pourra peut être faire plus optimisé en codant ton appli pour tes besoins mais je doute que tu gagnes beaucoup en perf et tu perdras du temps !....

A moins que tu ne tunes ta connexion en jouant sur les paramètre mémoire de ta session avec des alter session.

Mon conseil est de prendre sql*loader et utiliser son mode direct path.

[falcon74]

SQL Loader est bien codé avec OCI, merci de la confirmation.
Je m'en doutais mais je voulais en être sur.

En fait je regarde OCI car SQL loader à quelques limitations au niveau de son fichier de contrôle qui nous oblige à faire au moins 8 fichiers de contrôle, et donc 8 passes, pour injecter toutes les lignes du fichier (qui fait au minimum 6 Go au passage).

Les limites sont de ne pas pouvoir faire des tests avec <, > ou que le fichier de contrôle ai une taille maximale.

Je sais que si j'utilise OCI cela va me prendre du temps, mais je dois de toute façon faire un programme pour d'autre prétraitement.

Au début je me disais que j'appellerai juste SQL Loader depuis mon programme, mais les limitations ne me le permettent pas.

Je pense donc que je vais regarder du coté d'OCILIB . Cela devrait me faciliter le travail.

[Vincent Rogier]

Effectivement OCILIB te facilitera le travail....

Généralement, le rapport de volume de code est de minimum de 4:1 en faveur de OCILIB sans parler de la lecture et la la maintenance du code ou la, y pas photo.

PS : OCILIB v3.0.0 va sortir fin septembre... Grosse version majeure avec plein de nouveautés !

[falcon74]

C'est clair que ca va etre plus facile avec OCILIB, surtout que je vais pas etre le seul à développer le programme et que le C pour les petits nouveaux c'est pas leur tasse de thé, alors avec du pure OCI ...

C'est aussi une très bonne nouvelle la sortie de la nouvelle version, car pour avoir l'autorisation d'utiliser une lib opensource, il faut prouver au chef qu'elle est maintenue en cas de problème.

[Vincent Rogier]

juste pour infos, la prochaine version d'ocilib qui sort début avril supporte désormais l'api direct path de sql*loader.

Exemple d'application :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
#include "ocilib.h"
 
#define SIZE_TAB  1000
#define SIZE_COL1 5
#define SIZE_COL2 10
#define SIZE_COL3 6
#define NUM_COLS  3
 
int main(void)
{
    OCI_Connection *cn;
    OCI_DirPath    *dp;
 
    char arrval1[SIZE_TAB][SIZE_COL1+1];
    char arrval2[SIZE_TAB][SIZE_COL2+1];
    char arrval3[SIZE_TAB][SIZE_COL3+1];
 
    int arrsize1[SIZE_TAB];
    int arrsize2[SIZE_TAB];
    int arrsize3[SIZE_TAB];
 
    int i;
 
    IF (!OCI_Initialize(err_handler, NULL, OCI_ENV_DEFAULT))
        RETURN EXIT_FAILURE;
 
    cn = OCI_ConnectionCreate("db", "usr", "pwd", OCI_SESSION_DEFAULT);
    dp = OCI_DirPathCreate(cn, "USR", "test_dp", NULL, NUM_COLS, SIZE_TAB);
 
    /* optionnal attributes to set */
 
    OCI_DirPathSetBufferSize(dp, 128000);
    OCI_DirPathEnableCache(dp, TRUE);
    OCI_DirPathSetCacheSize(dp, 1000);
    OCI_DirPathSetNoLog(dp, TRUE);
    OCI_DirPathSetParallel(dp, TRUE);
 
    /* describe the target table */
 
    OCI_DirPathSetColumn(dp, 1, "VAL1", SIZE_COL1, NULL    , 0, 0, FALSE);
    OCI_DirPathSetColumn(dp, 2, "VAL2", SIZE_COL2, NULL    , 0, 0, FALSE);
    OCI_DirPathSetColumn(dp, 3, "VAL3", SIZE_COL3, "DDMMYY", 0, 0, FALSE);
 
    OCI_DirPathPrepare(dp);
 
    /******* method 1 : set each array entry  ******/
 
    FOR (i = 0; i < SIZE_TAB; i++)
    {
        /* fill test values */
 
        sprintf(arrval1[i], "%d", i);
        sprintf(arrval2[i], "val %05d", i);
        sprintf(arrval3[i], "130309");
 
        OCI_DirPathSetEntry(dp, i, 1, arrval1[i], -1, TRUE);
        OCI_DirPathSetEntry(dp, i, 2, arrval2[i], (int) strlen(arrval2[i]), TRUE);
        OCI_DirPathSetEntry(dp, i, 3, arrval3[i], (int) SIZE_COL3, TRUE);
    }
 
    /* load data to the server */
 
    OCI_DirPathConvert(dp);
    OCI_DirPathLoad(dp);
 
    /* reset path stream */
 
    OCI_DirPathReset(dp);
 
    /****** method 2 : pass arrays in one call ******/
 
    FOR (i = 0; i < SIZE_TAB; i++)
    {
       /* fill test values */
 
        sprintf(arrval1[i], "%d", i);
        sprintf(arrval2[i], "val %05d", i);
        sprintf(arrval3[i], "130309");
 
        /* setup sizes */
 
        arrsize1[i] = -1;
        arrsize2[i] = (int) strlen(arrval2[i]);
        arrsize3[i] = SIZE_COL3;
 
    }
 
    OCI_DirPathSetArray(dp, 1, arrval1, arrsize1);
    OCI_DirPathSetArray(dp, 2, arrval2, arrsize2);
    OCI_DirPathSetArray(dp, 3, arrval3, arrsize3);
 
    /* load data to the server */
 
    OCI_DirPathConvert(dp);
    OCI_DirPathLoad(dp);
 
    /* commit data */
 
    OCI_DirPathFinish(dp);
 
    /* free direct path object */
 
    OCI_DirPathFree(dp);
 
    OCI_Cleanup();
}

[falcon74]

J'ai enfin eux le temps de lire ton exemple, et effectivement si les perfs sont similaire au mode bulk, c'est très intéressant et bien plus dans la logique de ce que je dois faire, je vais essayer.

D'ailleurs je suis en train de galérer avec le mode bulk, j'ai un souci avec les dates :

Quand j'injecte plusieurs lignes à la fois, aucun problème les dates sont bien formatées à l'insertion.

Mais quand j'injecte une seule ligne, cas rare mais qui peux m'arriver,et bien la date est mal formatée.

J'ai fait un test depuis l'exemple de bulk du tutoriel :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
int main()
{
    OCI_Connection *cn;
    OCI_Statement *st;
 
    int tab_int[1000];
    char tab_str[1000][21];
    OCI_Date* tab_date[1000];
 
    int i;
 
    IF (!OCI_Initialize(NULL, NULL, OCI_ENV_DEFAULT))
        RETURN EXIT_FAILURE;
 
    // ... CREATE connection AND statement ... 
 
    cn = OCI_ConnectionCreate("XE", "ais", "ais", OCI_SESSION_DEFAULT);
    st = OCI_StatementCreate(cn);
 
    // binding 
 
    OCI_Prepare(st, "insert into table_teste values(:i, :s, :d)");
    OCI_BindArraySetSize(st, 1);
    OCI_BindArrayOfInts(st, ":i", (int*) tab_int, 0);
    OCI_BindArrayOfStrings(st, ":s", (char*) tab_str, 20, 0);
    OCI_BindArrayOfDates(st, ":d", (OCI_Date**) tab_date, 0);
 
    // filling arrays 
    FOR(i = 0; i < 1 ; i++)
    {
        tab_int[i] = i+1;
        sprintf(tab_str[i],"Name %d",i+1);
        tab_date[i] =  OCI_DateCreate(cn);
        OCI_DateSysDate(tab_date[i]);
    }
 
    // execute 
 
    OCI_Execute(st);
 
    printf("row processed : %d\n", OCI_GetAffectedRows(st));
 
    OCI_Commit(cn);
 
    OCI_Cleanup();
 
    RETURN EXIT_SUCCESS;
}

[Vincent Rogier]

salut,

effectivement, dans le cas de liaison de tableau, si le nombre d'éléments du tableau était = 1, la valeur pouvait être mal insérée dans la base...

Je viens de la corriger et cela sera inclus dans la 3.2.0 qui sort début de semaine prochaine.

voici l'entrée du changelog concernant ce bug :

- Fixed Array binding with array size = 1 : for non scalar types binds, corrupted data could be inserted or an error could be raised

et pour la remontée du bug

[falcon74]

J'ai testé l'injection d'une ligne avec la 3.2.0, ca marche sans problème.

Pour le mode direct path, j'essaye et je te fais un retour sur mes impressions d'utilisation.

[Vincent Rogier]

Envoyé par falcon74

Pour le mode direct path, j'essaye et je te fais un retour sur mes impressions d'utilisation.

cool

[Vincent Rogier]

des nouvelles de tes tests ?

[falcon74]

J'ai pas encore eu le temps de tester.

J'ai d'autres fonctionnalités récalcitrante du prog à finir avant de pouvoir remplacer le mode bulk par le direct path.

J'espere pouvoir faire des tests d'ici à Lundi.

[falcon74]

Je suis en train d'implémenter le mode direct path et j'ai un souci avec la fonction OCI_DirPathSetArray.

Je ne trouve pas sa description dans l'aide en ligne de ton site et elle n'a pas l'air d'etre connu dans la lib

Aurais-tu une idée ?

[Vincent Rogier]

cette fonction, prévue dans l'implémentation initiale, a été retirée de la version finale car ne servant a rien (car ocilib gère déja un tableau interne à cause des bugs oci en utf16...).

Il faut utiliser OCI_DirPathSetEntry()

[falcon74]

Ok, il faut donc que j'adapte un petit peu plus mon prog.

Avec le mode bulk, j'avais defini mes classes pour qu'elle me génère directement les tableaux de valeurs.

Donc ca va prendre un chtit peu plus de temps avant de pouvoir faire un test

[Vincent Rogier]

tu peux garder les tableaux.

fais juste un loop à la fin...

[falcon74]

oui, c'est une idée quand on réfléchit un peu

Il est temps que la journée se finisse ....

[Vincent Rogier]

Des nouvelles en cette veille de 1er mai ???

[falcon74]

Je suis dessus, j'ai du bosser sur d'autres trucs ces derniers jours, mais j'ai réussi à finir le portage depuis le mode bulk et en ce moment je me bats avec un segfault dans mon propre code, mais je pense qu'il va pas me bloquer trop longtemps

Donc si tout va bien, test aujourd'hui

[Vincent Rogier]

good