Version imprimable
:cry:salut,
Je cherche un code en C qui me permette d'ouvrir un fichier en accés séquentiel, de lire ligne à ligne et dès que je trouve une instruction \n, d'insérer la ligne précédente dans une table (base de données ORACLE).
Si quelqu'un a une piste
Bref, tu veux dire, insérer chaque ligne du fichier dans la base ?
Je ne pourrais t'aider pour le code d'insertion en base, mais j'ai une question pour les lignes:
Est-ce qu'elles ont une taille maximum ?
oui les lignes sont limitées à 86 caractères
Dans ce cas, la partie "lecture des lignes" est plutôt facile: Il suffit de lire les lignes avec fgets()...
Un code de ce genre (attention, je n'ai pas testé) devrait faire l'affaire...
Code:
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
Merci pour ton aide, mais je suis débutant en C, est-ce que tu pourrais si c'est possible commenter ton code en m'indiquant précisément les opérations décrites.
Merci d'avance
D'accord, je vais commenter un peu plus, vérifier que le code compile et poster la version commentée.
C'est super, merci encore
:yaisse2:
Voici le code commenté. Il compile sans erreurs ni warnings, sauf la variable inutilisée dans la fonction vide.
Note: Ce code n'est pas un programme, puisqu'il n'y a pas de fonction main() : Il s'agit juste de trois fonctions pouvant être utilisées dans ton programme.Code:
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
J'ignore comment tu veux utiliser ces fonctions, mais le moyen le plus simple, c'est un main() contenant juste un appel à la fonction avec le chemin absolu de ton fichier (on peut faire plus pratique ensuite).
Code:
2
3
4
5
En fait, j'ai plusieurs fichiers sous unix, qui permettent l'édition de factures, d'accusés, de devis... le tout en mode caractère bien évidemment.
nous sommes en train de migrer la solution en mode web. Pour cela on utilise des outils (Forms, report...).
Le but de l'opération est de lire ces fichiers d'édition, et d'insérer chaque ligne dans une table de la base de données, ce qui nous permettra à partir de cette table, de réinjecter les lignes dans un report.
Cà a pas l'air simple en le disant et encore moins en réalité.
D'où ma demande d'aujourd'hui. Je ne sais pas si tu peux affiner ta réponse selon ce qui je viens de t'exposer. C'est vrai que ça me serait très utile, vu que moi je suis plutôt spécialiste de JAVA et du développement web...
Eh bien, il y a plusieurs axes de développement.
- Si chaque ligne du fichier correspond à une ligne en base, elle contiendra sûrement plusieurs champs. Ces champs, il faudra les séparer, il y a plusieurs moyens pour cela. Si l'on retire le const dans le prototype de la fonction void EnvoyerLigneEnBase(char const * ligne), on s'ouvre un moyen supplémentaire de décomposer la ligne à peu de frais.
- On peut aussi s'orienter vers la façon d'utiliser la fonction. Par exemple, faire du programme C un programme en ligne de commande qui prendrait le chemin du fichier en paramètre, au lieu de l'avoir directement dans son code.
PS: Je rappelle que je n'y connais rien aux communications avec base de données en C. Mais quelqu'un d'autre sait sûrement quelque chose...
Je pencherais plutôt pour la première solution. Si je t'ai bien suivi, il suffit de remplacer
parCode:int EnvoyerLigneEnBase(char const* ligne)
Code:int EnvoyerLigneEnBase(char * ligne)
Ce ne sont pas deux solutions au même problème, ce sont deux axes d'approche différents (et on peut faire les deux, et on finira sûrement par faire les deux).
Le remplacement que tu viens de décrire est bien celui dont je parlais, mais il n'est pas lui-même le moyen: Ce remplacement n'est qu'un outil permettant d'utiliser un meilleur outil à peu de frais.
Supposons que chaque ligne contienne des valeurs séparées par des points-virgules. Par exemple, pour une table à trois colonnes numériques:
(la suite arrive)Code:
2
Pour ceci, la première chose à faire est de séparer les champs: Comme on n'a pas de vérification compliquée à faire (comme vérifier qu'un ; n'est pas dans une chaîne) puisqu'il n'y a pas de chaîne, nous pouvons utiliser directement la fonction standard strtok() pour la séparer selon les points-virgules.
Note: Cette fonction a certains inconvénients et est déconseillée quand il y a une alternative disponible, notamment strtok_r(). Mais il n'y a pas toujours d'alternative, et les inconvénients ne se manifesteront pas dans notre petit programme.
Note: strtol() est déclarée dans le fichier d'en-tête <stdlib.h>, donc il faut rajouter en tête de fichier source:Code:
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
Code:#include <stdlib.h> /* Principales fonctions de biblio standard. */
Si je comprends bien, il s'agit d'une opération de migration unique (on migre puis on bosse ensuite dans le système migré) alors pourquoi le faire en C ? Le C est très rapide mais très très bas niveau (faut réserver la mémoire, regarder si on a tout lu, etc).Citation:
Envoyé par gege87270
Tu pourrais t'orienter vers des langages plus simples comme le shell
Exemple du même programme écrit en shell
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Si le fichier est très gros, cela peut être long. Tu peux essayer Python qui est assez souple et hyper rapide
Le C c'est chouette mais quand on commence à se prendre la tête avec toutes les contraintes, ça va bien un temps...Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
J'avoue que j'ai mal à suivre. Je ne vois pas comment je pourrais utiliser ton exemple. Moi le fichier que je lis est un fichier texte qui représente une édition papier.
Par exemple :
-----------------------------------------------------------------
Le 23/10/2007
Limoges,
Code client : Xp00014
Facture
_________________________________________________________
Ref | Désignation |Prix HT | Prix TTC |
_________________________________________________________
a |xxxxxxxxxxxxxxxxxxxx |10.25 |15.64 |
_________________________________________________________
Total : 15.64
-----------------------------------------------------------------
Ce que je veux c'est lire ce fichier ligne à ligne et dès que je trouve un\n, (saut de ligne), je copie la ligne dans ma table et ainsi de suite jusqu'à la fin du fichier.
je crois que j'ai répondu en même temps que toi. Mon dernier post concerné ton post précedent.
Je suis intéressé par le shell dont tu m'as parlé..
Ce fichier texte me semble trop compliqué pour une analyse aussi simple.
Le fichier, tu cherches à le mettre en base sous quel format exactement ?
Sous Oracle, j'ai créé une table (edit_pdf) avec 3 champs
pdf_proc : number (qui contiendra le n° de session utilisateur) variable proc dans mon code.
pdf_nligne : number (qui contiendra le n° de ligne de la ligne récupérée dans le fichier)
pdf_ligne : varchar(85) (qui contiendra le contenu de la ligne)
le but étant de lire le fichier en accès séquentiel (ligne à ligne) et dès que l'on trouve un \n (retour à la ligne), on copie la ligne (concaténation si plusieurs éléments), dans la table edit_pdf. Je pense que cette partie intégration doit se faire via des requêtes sql.
J'ai déjà mis en place un shell avec awk qui me permet de retraité une première fois les programmes .pc (ajout, suppression, modification de ligne). Cette partie fonctionne très bien. J'avais envisagé de mettre en place des structures de contrôle (via des if) pour pouvoir faire le traitement qui m'intéresse, mais sur des codes de plus de 3000 lignes, c'est un travail fastidieux et on n'est pas à l'abrit d'un oubli.
C'est pourquoi je me suis tourné vers cette lecture séquentielle, qui me parait être la meilleure solution.
Ah OK, donc c'est plus simple que je le pensais: C'est vraiement chaque ligne qui est envoyée en tant que texte brut dans la base.
Il n'y a donc pas d'histoires de séparation en champs, etc. donc tu peux oublier mes posts #12 et #13.
Et le pointeur de la fonction EnvoyerLigneEnBase() peut redevenir const.
Mais cela ne nous dit pas comment, en C, se connecter à une base de données Oracle et y insérer une ligne dans une table.
Toutefois, cela nous laisse la place à des améliorations du code:
- La variable proc doit être connue dans le programme de lecture séquentielle. Cela pourra être un paramètre en ligne de commande, nous reviendrons dessus plus tard. Ce qui est sûr, c'est qu'il faudra que la fonction EnvoyerLigneEnBase() le connaisse. Nous allons donc lui rajouter un paramètre, qui sera passé directement à travers les fonctions LireFichier() et LireFichierOuvert(). Ce paramètre sera un pointeur générique, comme on ne sait pas encore quoi passer.
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- L'autre amélioration est le numéro de ligne: Nous ajouterons un comptage de lignes dans la fonction LireFichierOuvert(), et un troisième paramètre à la fonction EnvoyerLigneEnBase().
Code:
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
Note: Je n'ai pas testé ni essayé de compiler, mais c'est l'idée générale.
Ok, on avance,
Je vais regarder ça.
A titre d'info, voilà le bout de code en pro*C pour se connecter à une base Oracle
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19/* -------------------- debut programme ---------------------------------- */ main(argc,argv) . . . char *zTmp; . . . /* -------------------- connexion base ORACLE --------------------------- */ zTmp=getenv("LOGINAME"); if(zTmp) strcpy(CUser.arr,zTmp); else strcpy(CUser.arr,"00000001"); setLen(CUser); EXEC SQL CONNECT :CUser IDENTIFIED BY :CUser; printf("Execution programme <%s> en cours....\n" ,argv[0]);