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]);
En tout cas merci pour ton aide.
Si tu peux me tracer la démarche générale, avec l'intégration d'un main, ça m'arrangerait.
Eh bien, la démarche générale, c'est de passer à EnvoyerLigneEnBase() une structure contenant toutes les informations nécessaires pour envoyer la chaîne à Oracle.
Typiquement, faire la connexion dans le main(), remplir la structure avec les champs qui vont bien, et passer le tout à la fonction LireFichier().
On pourra aussi s'orienter vers le second axe de développement que j'avais mentionné: La prise de paramètres (comme le nom de fichier et/ou la valeur de proc) en ligne de commande.
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
Super,
Je dois m'absenter ce matin, mais je regardes ça cette après midi. J'essaie de remplir un peu ton code avec mes paramètres, je te le fais passer pour avoir ton avis.
Essaye de citer les réponses auxquelles tu réponds car sinon on ne s'en sortira pas.Citation:
Envoyé par gege87270
Personnellement moi je dis que faire ça en C c'est faisable mais très compliqué et faut passer par des langages plus adaptés à ce genre de cas (shell, python) et/ou des outils déjà fait (sed/awk/tr) avec intéraction possible (shell/awk, shell/sed, python/tr etc). Mais évidemment à la base faut déjà être à l'aise en prog dans ces différents langages...
Suite à ton dernier message, si tu as une idée avec un prog shell avec awk, je suis preneur.
Voilà le code que je viens de modifier.
Tu remarqueras que je n'ai pas trop avancé. J'ai compilé le code avec Dev C++ ça à l'air de fonctionner mis à part la partie int main(int argc, char *argv[]).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
OK, examen rapide:
- Tu devrais désormais pouvoir utiliser pParams->sessionid dans EnvoyerLigneEnBase().
- Dans le main(), on ne sait pas quels sont les types de cUser et cPasswd, ils ont l'air de ne pas être déclarés.
- Dans le main(), le premier paramètre de LireFichier() ne doit pas être sessionid mais le nom du fichier à lire.
- Une minute: Tu SAIS te servir de Pro*C, au moins ?
Pour le Pro*C je devrait m'en sortir pourquoi ?
Parce que j'ai vu le code avec les argv[3] alors qu'on n'a pas encore définit ce que le programme devrait prendre en ligne de commande.
Et il me fait penser à du "copier-coller au hasard", surtout qu'il utilise des variables non-déclarées et ouvre un fichier en écriture pour des raisons qui m'échappent...
Bien vu, c'est que j'ai fait des test dans un shell et tu as raison j'ai recopié bêtement sans réfléchir.
Voilà en fait ce que j'ai modifié
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
Pas vraiment évident au premier abord surtout qu'on ne sait pas trop ce que tu veux récupérer comme info. Moi, je partirais sur une analyse shell ligne par ligne avec évaluation de la ligne où je me trouve selon un indicateur de positionCitation:
Envoyé par gege87270
Un exemple de base tapé un peu à la va-vite
Bon, c'est assez lourdeau comme style de programmation mais faut dire que ton fichier est assez pourri dans son genre. Surtout que je me base pour l'écrire sur des items qui peuvent changer avec le temps (si demain le patron décide qu'une facture doit avoir des "+++++" à la place des "-------" ben le script => poubelle).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
Ceci me fait dire que peut-être tu as un défaut dans ta conception. Peut-être tu pourrais essayer de remonter plus haut à la source pour essayer de récupérer les infos là où elles sont avant qu'un programme annexe que tu ne maîtrises pas les traite pour en générer ce fichier boiteux que toi tu devras analyser et ingérer.
Bien entendu j'ose espérer que tu as aussi quelques bonnes bases en shell pour pouvoir faire ce travail car c'est pas à la portée du premier débutant venu...
Euh... C'est encore pire qu'avant... :|Citation:
Envoyé par gege87270
Sve@r,
l'exemple que je donne est pourri je le reconnais, mais c'était pour donner une idée de la structure de mes fichiers d'édition. En aucun cas cela reflète la réalité. Les éditions se font sur des feuillets près imprimés, seules les infos sont éditées. Je n'ai pas besoin de tenir compte des --- ou des ____.
Ce qui m'intéresse c'est de lire ces fichiers en séquentiel, et lorsque je trouve un \n ou un ^L je copie la ligne pour l'insérer dans une table sous ORACLE.
MEDICOC,
Je pense sans offenser sve@r que ta méthode est la bonne. Si tu pouvais affiner le code que tu as déjà conçu, ça me serait d'une grande utilité.
Merci à vous deux.
J'ai affiné un peu mon code, en indiquant les fonctions où tu devais mettre le code en Pro*C (voir les commentaires en majuscules).
J'ai également ajouté le code de lecture des paramètres en ligne de commande. Le programme s'emploie ainsi (exemple) :
Code:programme.exe "C:\MonFichierTexte.txt" 42
Note: Ça compile, mais je n'ai pas testé.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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
Mon collègue va prendre la suite du développement, notamment pour le pro*C. Bien évidemment je te tiens informé de la suite, et si ça t'intéresse, je te ferais passer le code complet.
Merci encore pour ton aide précieuse.