ISAM vs BDR database

@ Klaus,

Tu as créé BDR (Base de Données Relationnelle ) il y a plusieurs mois maintenant.
Aujourd' hui, c' est ISAM ta victime ( Laughing

).

Pourrais tu, sans rentrer dans des détails trop complexes, nous dire l' avantage de l' un sur l' autre ?
Dans quels cas de figure est il plus judicieux d' utiliser l' un plutôt que l' autre ?

Dans certains cas, un Programme/Logiciel ( appellation au choix Laughing

) doit utiliser plusieurs bases.
Je prends exemple sur un sujet que je connais, la gestion d' une écurie de courses, on a plusieurs bases :

Chevaux
Propriétaires (clients)
Salariés
Intervenants & Fournisseurs
Courses
etc...

Parfois, la somme des enregistrements d' un champ d' une des bases sert à remplir le champ d' un enregistrement
d' une autre.
Avec Panoramic, il faut que ce calcul se fasse par programme et mise à jour de la base.
Dans certains logiciels, le champ contient une équation et à l' affichage donne le résultat.

Un cas comme celui ci laisse perplexe sur la solution à adopter et il doit y en avoir d' autres... Twisted Evil

( SVP ! Le sujet n' est pas simple pour les petits esprits tel que le mien. Si on pouvait, pour une fois, éviter la pollution... )

Effectivement, Ygerinomi, la question est légitime. BDR et ISAM sont tous deux des systèmes de gestion de fichiers, et les deux ont meurs points forts et leurs points faibles.

Commençons par BDR, qui est le plus ancien. BDR est plus qu'un système de gestion de fichiers. C'est une véritable base de données relationnelle. On travaille ici avec des "entités" (on peut dire aussi des "objets") qui de sont pas directement synonyme d'enregistrements. Une entité porte un nom et est identifiée par son nom. Il ne peut y avoir de doublons pour un nom. Et le point fort de BDR est de définit des relations (d'où le nom) entre les entités, sous forme de triplets:
(entité A) (est en relation R avec) (entité B)
ou plus simplement:
A=(R)=>B
Dans cette notation, A, R et B sont des entités.

Cette relation est "orientée": A=(R)=>B n'implique pas B=(R)=>A ! Tu es perdu ? Alors, un exemple pour comprendre ! Supposons que nous ayons les entités Martin et Jacques, ainsi que l'entité "est_père_de". Alors:
Martin est_père_de Jacques
peut être créé comme relation. Mais dans ce cas, l'inverse n'est pas vrai:
Jacques est_père_de Martin
n'a pas de sens !

Tu peux définir autant de relations que tu veux, et une entité peut participer à autant de "triplets", de liens, que nécessaire. Par exemple, Martin peut être père d'autres entités, mais peut être également le point de départ d'autres relations, comme par exemple est_marié_avec ou possède etc. Par exemple:
Martin est_père_de Jacques
Martin est_père_de Jeanne
Martin est_père_de Béatrice
Martin est_marié_avec martine
Martin possède Clio

L'intérêt d'une telle structure, c'est sa capacité de répondre à des interrogations. Reprenons la notation A=(R)=>B. Si on remplace une ou plusieurs entités par un point d'interrogation, BDR est capable de trouver, rapidement, la ou les réponses qui satisfont la question. Exemple:
A=(R)=>B comme question demande à BDR de vérifier si A est bien en relation R avec B.
A=(R)=>? demande à BDR quel(le) entité(s) est(sont) en relation R avec A. Exemple:
Martin est_père_de ?
Réponse: Jacques, Jeanne et Béatrice !
Mais il y a mieux !
Martin ? Jacques demande à BDR en quel relation est Martin par rapport à Jacques. Réponse: "est_père_de".
Et même:
?est_père_de Jacques demande à BDR qui est le père de Jacques. Réponse: Martin !
Et encore:
Martin ? ? demande à BDR ce qu'il sait sur Martin. Bdr va répondre:
Martin est père de Jacques, Jeanne et Béatrice,
Martin est marié avec Martine,
Martin possède Clio
etc. Toutes les combinaisons de noms d'entités et de "?" sont possibles.

C'est ça, une base de donnée relationnelle. On a des liens directionnels entre deux entités, et ces liens portent des noms et sont eux-même des entités. On peut construire un réseau complexe de relations entre des milliers d'entités, et toujours trouver immédiatement la ou les réponses aux questions posées à la BDR.

Accessoirement, la BDR peut également gérer des données, mais c'est une fonctions vraiment accessoire, et ces données ne participent en rien à la structure logique construite par ces relations. Mais ces données peuvent avoir une longueur différente d'une entitéà une autre, ou être totalement absentes.

Donc, ce système est particulièrement adapté là où des hiérarchies par arborescence sont importantes, comme dans un logiciel de généalogie, par exemple, ou l'enregistrement des animaux d'un élevage dont, je suppose, l'arbre généalogique est également important, ou une gestion de pièces détachées où l'on part d'un ensemble complexe (voiture, moteur, ordinateur, ...) composé de sous-ensembles eux-mêmes composés de sous-ensembles, etc, jusqu'à la dernière rondelle.

Passons maintenant à ISAM, le plus récent. Il y a une différence fondamentale. Ici, l'unité de base de l'information est un "enregistrement", et il n'y a pas de "nom". Tous les enregistrements ont la même longueur. Les enregistrements sont structurés comme une suite de champs, ayant tous une longueur prédéfinie au moment de la création du fichier. Tous les enregistrements d'un même fichier ISAM sont découpés de la même manière. Ces enregistrements sont uniquement des champs de type texte (alpha-numérique).

Pour s'y retrouver, on définit au moins 1 clé pour un fichier ISAM, ou au maximum 32 clés. Chaque clé est composé d'une suite de 1 à 16 champs de l'enregistrement, dans n'importe quel ordre, pas forcément celui dans lequel ils apparaissent dans l'enregistrement. Lors de l'ajout d'un enregistrement, le système ISAM va automatiquement construire les clés nécessaires et les ajouter dans un fichier index associé au fichier données.

On peut alors chercher directement l'enregistrement dont la clé 3 a une valeur précise, sans connaître sa position dans le fichier ni la valeur des autres clés. Mieux: à partir d'un enregistrement lu (ou à partir du début ou de la fin d'un des indexes), on peut lire l'enregistrement suivant ou précédent selon la clé choisi. Un exemple:
Prenons un fichier des employés. Des champs évidents sont:
Nom
Prénom
Date de naissance
Date d'embauche
Numéro de SS
Numéro identifiant le salarié
Catégorie d'emploi
Secteur d'emploi
etc.
Et il est certainement utile de pouvoir trouver un salarié selon sont nom/prénom, selon son numéro de SS ou son numéro identifiant. Il est également utile de pouvoir traiter tous les salariés d'une certaine catégorie, ou embauchés avant une certaine date. Toutes ces interrogations pourront être faites facilement en définissant des clés d'accès utilisant les champs correspondants, et on les traite ensuite directement, sans avoir à lire séquentiellement tout le fichier. On a ainsi un gain de temps énorme, et surtout, en choisissant la bonne clé d'accès, on a les enregistrements qui sont présentés directement dans le bon ordre, sans avoir de tri à faire.

Il est évident que dans un tel système, chaque fichier ISAM ne peut contenir que des enregistrements concernant le même type d'nformation. Tous ces éléments:
Chevaux
Propriétaires (clients)
Salariés
Intervenants & Fournisseurs
Courses
seraient gérés dans des fichiers ISAM distincts, chacun avec ses champs appropriés et ses clés définies en fonction des traitements qu'on souhaite faire sur ces informations. Et le lien entre ces fichiers sera effectué en plaçant des champs dans leurs enregistrements contenant la copié d'une clé d'accès vers un enregistrement d'un autre fichier. Un exemple:
Fichier des chevaux
Champs: nom du cheval, box, date de naissance, code propriétaire
Fichier des propriétaires
Champs:
code propriétaire, nom, prénom, nom du cheval
Ainsi, ayant lu un enregistrement "cheval", on peut lire directement l'enregistrement "propriétaire" par sa clé "code propriétaire". Inversement, ayant un enregistrement propriétaire, on peut lire directement l'enregistrement "cheval" par sa clé "nom du cheval".

Inconvénient: un propriétaire ayant plusieurs chevaux ? A partir d'un enregistrement "cheval", on peut retrouver le propriétaire, comme indiqué ci-dessus. Mais si ce propriétaire a plusieurs chevaux, il faut, soit, autoriser des doublons sur la clé "code propriétaire" et créer autant d'enregistrements propriétaire du même code qu'il a de chevaux, ce qui pose évidemment le problème de la modification des informations su propriétaire comme son adresse, ou son téléphone, car il faudra faire ces mises à jour dans tous les enregistrements ayant le même code propriétaire. Soit, il faut définir plusieurs champs "nom de cheval" dans l'enregistrement "propriétaire", et prévoir 5, 10, 30 ou 100 de ces champs, par exemple.

Toujours est-il que ce système est la base d'une multitude d'applications de gestion, et avant la percée des bases de données SQL ou autres, ces fichiers constituaient le seul moyen de faire des comptabilités, des paies, des facturations ets.

L'utilisation simultanée de BDR et ISAM est possible ! Car pourquoi les opposer ? Comme je l'ai dit, les dux systèmes ont leur points forts et leurs points faibles ! Dans l'exemple que tu suggères, on pourrait avoir:
un fichier ISAM "propriétaires", avec des champs
code propriétaire, nom, prénom, adresse, ...
un fichier ISAM "chevaux", avec des champs
code cheval, nom cheval, dans naissance, box, ...
et un fichier BDR avec une entité par propriétaire, le nom de l'entité étant le code propriétaire, une entité par cheval, le nom de l'entité étantle code cheval, et la relation "possède".
On définit ainsi les relations (code propriétaire)=(possède)=>(code cheval) pour chaque couple propriétaire/cheval. Et, immédiatement, on peut savoir quels chevaux possède un propriétaire donné, etc.

On peut définir d'autres relations, en considérant le fichier ISAM des employés (comprenant les lads et les jockeys) et le fichier ISAM des intervenants (comprenant les vétérinaires):
"vétérinaire_de", "soigneur_de", "cavalier_de"
avec les triplets:
(vétérinaire)=(vétérinaire_de)=>(code cheval)
(lad)=(soigneur_de)=>(code cheval)
(jockey)=(cavalier_de)=>(code cheval)
La simple question
(?)=(?)=>(Cheval17)
donne alors le propriétaire, le (ou les) vétérinaire(s) s'occupant de ce cheval, le lad soigant le cheval ainsi que son jockey.

Je ne suis pas du tout spécialiste des activités équines, mais je peux parfaitement imaginer une structure cohérente et logique qui va se refléter par la définition d'un ensemble de fichiers ISAM, assisté d'une BDR, répondant à toutes les exigences formulées par un client. Cela s'appelle "analyse" d'une application de gestion et est la base d'une application réussie.

Bon, je m'aperçois que, comme d'habitude, je me suis laissé emporter par mon enthousiasme et j'ai pondu un éditorial au lieu d'une réponse simple. A ma décharge, je dirais qu'il n'y a pas de réponse simple et passe-partout - simplement une analyse approfondie des données à gérer et des résultats à obtenir,, pour définir la structure de support permettant de réaliser cela de façon optimale. Car personne, et surtout pas moi, ne peut dire avoir une solution tout faite, idéale, pour chaque cas. C'est de la fumisterie. Il n'y a que l'élaboration d'un compromis, savamment dosé, entre plusieurs outils, dont l'harmonie conduira à la satisfaction des besoins du client. C'est ça, la réussite d'un projet de gestion, et non un résultat technique opérationnel, aussi brillant soit-il, s'il ne correspond pas aux besoins.

Professeur Klaus, je reste bouche bée et admiratif !

Merci pour cette éclaircissement Klaus.

Comme tu le dis, la réussite d' un logiciel vient du fait
qu' il accomplit ce qu' on lui demande et, malheureusement,
dans le domaine équin s' est très rarement le cas et ceux qui s' approchent
le plus d' une aide plus efficace que les documents papiers sont à des prix... affraid

Lorsque tu gères une écurie de 200 chevaux cela vaut le coup d' acheter mais pour des
structures d' une dizaine de chevaux c' est prohibitif.
On a aussi le cas dans les logiciels de programmation auxquels peu de Panoramicien
pourrait accéder pour un usage personnel.

Bref, je sens que je suis parti pour des heures de lecture avant de sortir l' application
que je voudrai.

En tout cas, je ne sais pas encore comment combiner les deux (BDR et ISAM) mais
le fait que cela soit possible me réjouit même si cela m' a l' air plus complexe que
de créer un éditeur... Laughing

Merci à toi pour cette réponse.

PS: Ton texte ferait un très bon article pour le mag, il répond à des interrogations que je ne dois pas
être le seul à m' être posé.

Oui, il est possible de faire cohabiter plusieurs fichiers ISAM et une BDR. Pars sur l'idée de gérer chaque type d'information (cheval, propriétaire, intervenant, fournisseur, salarié, ...) par un fichier ISAM, avec un dessin d'enregistrement ayant un champ pour chaque information à gérer pour un élément du fichier concerné.

Utilise ensuite la BDR pour établir les liens logiques (et modifiables, dans la plupart des cas), pour établir les liens entre éléments, qu'il s'agisse de liens à priori fixes (comme cheval/propriétaire, sauf cas de vente...) ou de liens variables plus facilement (comme lad/cheval, vétérinaire/cheval, ...).

Fais ensuite une conception en 3 grands volets:
1. maintenance des fichiers de base, avec la création, suppression et modification des enregistrements de chaque fichier. Définir pour cela la liste exhaustive des fichiers, y compris celui des "installations" avec leur planning d'utilisation, d'éventuels véhicules et leur planning etc.
2. maintenance des liens BDR en indiquant qui s'occupe de quoi, etc
3. application proprement-dite avec les traitements utilisant la structure établie, pour renseigner des informations spécifiques (traitements vétérinaires prescrits/appliqués, activités d'entraînement, changement de lad, régime alimentaire, etc - que sais-je.

A chaque étape, soigner la présentation visuelle avec peu d'informations affichées à la fois, au besoin utiliser CONTAINER_TAB et TAB pour regrouper les champs par type d'information, et avoir, partout, les COMBO ou CHECK pour saisir des informations dont les valeurs comprises dans un ensemble de possibilités limités et connues.

Ne pas oublier les éditions écran/papier sous forme de listes et/ou tableaux, éventuellement avec le module de gestion des impressions de KGF.dll (tant qu'on y est, utiliser KGF.dll au maximum !).

Et je pense que là, tu peux obtenir un logiciel souple, puissant et agréable à utiliser. Et, en cas de besoin, n'hésite pas à me demander conseil...

@Ygeronimi
Jette un œil ici.

@ Papydall,
Le plus fonctionnel est Win Ecurie 2004 mais c' est un shareware...
Trot Pedigree, je l' ai, c' est une "big" base de données généalogique très bien quand on fait de l' élevage pour choisir
un étalon et connaitre sa descendance ou l' ascendance d' un cheval trotteur mais pas de gestion.
Les autres sont tournés "Centre Equestre" et pas "Ecurie de courses" ( les différences dans la gestion sont énormes )...

@Ygeronimi:

Pour t'aider à mieux démarrer avec ISAM, je t'ai fait une SUB qui doit être appelée au début du programme, après avoir chargé KGF.dll. Elle initialise l'environnement du système ISAM, crée les variables indispensables, crée un identifieur ISAM pour chaque fichier ISAM à gérer, puis vérifie l'existence des fichiers. Pour chaque fichier, s'il existe, il est ouvert, sinon créé. Pour la création, les paramètres sont données dans une suite de commandes DATA (avec commentaires), puis il y a le code pour exploiter ces paramètres. Au final, dans le programme principal, il suffit d'une ligne... Il n'y a plus qu'à allonger la liste des fichiers et à adapter les paramètres.

J'ai même défini un fichier "historique" qui gère la liste de toutes les courses dans lesquelles au moins un cheval a participé. Suivant les clés que j'ai définies, on peut avoir la chronologie des courses (clé 2), l'historique des courses pour un cheval (cle 1) ou l'historique des courses pour un jockey (clé 3). Mais ce ne sont que des exemples.

Voici le code:

Code:: ' demo_pour_Ygerinimi.bas

' L'exemple suvante montre comment définir une série de fichiers ISAM
' et les créer ou ouvrir automatiquement. Les paramétrages sont réalisés
' dans le code de la procédure, sous forme de DATA commentées.

ouvrir_fichiers()

end

' Cette sub ouvre les fichiers existants, ou les crée s'ils n'existent pas.
' Elle crée automatiquement le tableau IsamID%(..) avec autant de cellules que
' de fichiers définis. Ce tableau est rempli avec les identifiants des fichiers
' ISAM qui seront utilisés pour chaque accès à ces fichiers.
sub ouvrir_fichiers()
label creer_fichier, ouvrir_fichier : ' sous-programmes à usage interne !
' ici, créer une variable globale pour CHAQUE fichier ISAM, mais pas un tableau !
dim IsamID%(3) : ' faire un tableau avec un élément pour chaque fichier
dim_local nfic%, nchamp%, ncle%, nchampcle%
dim_local ific%, ichamp%, icle%, ichampcle%
dim_local def$, nom$, n%

' initialiser le système ISAM
res% = dll_call0("InitIsam")

' initialiser les variables de support pour chaque fichier ISAM:
' ATTENION:cette section doit être adapté au nombre réel des fichiers !
n% = res% = dll_call0("GetIsamIdentifierSize") : ' récupérer la taille des variables de support
' répéter les 4 lignes suivantes pour chaque fichier:
dim support_chevaux$
support_chevaux$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_chevaux$))
IsamID%(1) = res%
dim support_histo$
support_histo$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_histo$))
IsamID%(2) = res%
dim support_personnel$
support_personnel$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_personnel$))
IsamID%(3) = res%

' on définit 3 fichiers:
' chevaux
' champs:
' : 1 = nom du cheval = 40 caractères format A...A
' 2 = code du cheval = 8 caractères format 99999999
' 3 = date de naissance = 8 caractères format aaaammjj
' 4 = autre donnée = 20 caractères format A...A
' ... (4 champs, dans cet exemple)
' clés:
' 1 = nom du cheval = champ 1
' 2 = code du cheval = champ 2, clé unique
' historique_des_courses
' champs:
' 1 = code cheval = 8 caractères format 99999999
' 2 = nom de la course = 40 caractères format A...A
' 3 = date de la course = 8 caractères format aaaammjj
' 4 = code jockey = 8 caractères format 99999999
' 5 = place obtenue = 2 caractères format 99
' ... (5 champs, dans cet exemple)
' clés:
' 1 = historique cheval = champs 1 suivi de 3
' 2 = chronologie = champ 3
' 3 = historique jockey = champ 4 suivi de 3
' personnel
' champs:
' 1 = nom de l'employé = 40 caractères format A...A
' 2 = prénom = 40 caractères format A...A
' 3 = code employé = 8 caractères format 99999999
' 4 = type employé = 2 caractères formap 99 (jockey, lad, secrétaire, ...)
' 5 = date de naissance = 8 caractères format aaaammjj
' ... (5 champs, dans cet exemple)
' clés:
' 1 = par nom = champs 1 + 2
' 2 = code employé = champ 3, clé unique
'
' On va définir tous ces paramètres dans des DATA:
DATA 3 : ' nombre de fichiers définis dans cet exemple
' pour le premier fichier:
data "C:\Fichiers\chevaux" : ' nom ISAM du fichier (sans extension)
data 4 : ' nombre des champs
data 40,8,8,20 : ' liste des longueurs des champs
data 2 : ' nombre des clés
data 1,0 : ' première clé: 1 champ, doublons non interdits
data 1 : ' champ 1 pour la clé
data 1,1 : ' deuxième clé: 1 champ doublons interdits
data 2 : ' champ 2 pour la clé
' pour le deuxième fichier:
data "C:\Fichiers\historique_des_courses" : ' nom ISAM du fichier (sans extension)
data 5 : ' nombre des champs
data 8,40,8,8,2 : ' liste des longueurs des champs
data 3 : ' nombre des clés
data 2,0 : ' première clé; 2 champs, doublons non interdits
data 1,3 : ' champs 1 et 3 pour la clé
data 1,0 : ' deuxième clé; 1 champ, doublons non interdits
data 3 : ' champ 3 pour la clé
data 2,0 : ' troixième clé; 2 champs, doublons non interdits
data 4,3 : ' champs 4 et 3 pour la clé
' pour le troisième fichier:
data "C:\Fichiers\personnel" : ' nom ISAM du fichier (sans extension)
data 5 : ' nombre des champs
data 40,40,8,2,8 : ' liste des longueurs des champs
data 2,0 : ' première clé; 2 champs, doublons non interdits
data 1,2 : ' champs 1 et 2 pour la clé
data 1,1 : ' deuxième clé: 1 champ doublons interdits
data 3 : ' champ 3 pour la clé

read nfic% : ' prendre le nombre de fichiers
for ific%=1 to nfic% : ' boucle pour la définition d'un fichier
read nom$ : ' prendre le nom ISAM du fichier
res% = dll_call1("IsamFileExists",adr(nom$)) : ' tester si le fichier existe
if res%<0 : ' le fichier n'existe pas ?
gosub creer_fichier : ' alors le créer
else : ' sinon
gosub ouvrir_fichier : ' l'ouvrir
end_if
next ific%

exit_sub : ' fin de la phase d'ouverture

' sous-programme interne: créer un fichier ISAM
creer_fichier:
read nchamp% : ' prendre le nom de des champs
res% = dll_call2("CreateIsamFile",IsamID%(ific%),adr(nam$)) : ' créer un fichier vide

def$ = str$(nchamp%) : ' préparer le paramètre pour la création du fichier
for ichamp%=1 to nchamp% : ' boucle sur les champs
read n% : ' prendre la longueur d'un champ
def$ = def$ + "," + str$(n%) : ' et compléter la définition
next ichamp% : ' fin boucle sur les champs
res% = dll_call2("SetIsamFields",IsamID%(ific%),adr(def$)) : ' définir les champs

read ncle% : ' récupérer le nombre de clés pour le fichier
for icle%=1 to ncle% : ' boucle sur les clés
def$ = str$(ncle%) : ' initialiser la définition de la clé
read n% : ' lire l'indicateur d'unicité
def$ = def$ + "," + str$(n%)
read nchampcle% : ' récupérer le nombre de champs pour la clé
for ichampcle%=1 to nchampcle% : ' boucle sur les champs de la clé*
read d% : ' récupérer un numéro du champ de la clé
def$ = def$ + "," + str$(n%)
next ichampcle% : ' fin de boucle sur les champs de la clé
res% = dll_call2("SetIsamKeyFields",IsamID%(ific%),adr(def$)) : ' définir la clé
next icle% : ' fin de boucle sur les clés
return

' sous-programme interne: ouvrir un fichier ISAM
ouvrir_fichier:
res% = dll_call2("OpenIsamFile",IsamID%(ific%),adr(nom$)) : ' ouvrir un fichier ISAM existant
: ' maintenant, il fait dépasser les DATA inutiles pour ce fichier:
read nchamp% : ' prendre le nom de des champs

for ichamp%=1 to nchamp% : ' boucle sur les champs
read n% : ' prendre la longueur d'un champ
next ichamp% : ' fin boucle sur les champs

read ncle% : ' récupérer le nombre de clés pour le fichier
for icle%=1 to ncle% : ' boucle sur les clés
read n% : ' lire l'indicateur d'unicité
read nchampcle% : ' récupérer le nombre de champs pour la clé
for ichampcle%=1 to nchampcle% : ' boucle sur les champs de la clé*
read d% : ' récupérer un numéro du champ de la clé
next ichampcle% : ' fin de boucle sur les champs de la clé
next icle%
return

end_sub

Merci Klaus, je vais lire tout cela très attentivement. study

Je vais essayer de faire les choses étape par étape pour bien les assimiler :

- Mise en place de l' environnement ISAM ( ca c' est pas très compliqué )
- Création des fichiers
- Remplissage des fichiers
- Modification des fichiers
- Sauvegarde des fichiers
- Fermeture des fichiers

Une fois que j' aurai digéré tout ca, je regarderai comment coupler ISAM avec BDR... Laughing

Donc, je vais reprendre la lecture de l' article+la doc kgf+tes posts+...
et, ne t' inquiète pas, au premier souci je reviendrai vers toi.

Mais, pour ne pas me perdre et me faire les dents, je vais peut être prendre un sujet moins complexe que
la gestion d' une écurie de chevaux de course.

Bonne idée ! Alors, pour commencer, suis mon tuto que j'ai déposé pour LMP - ça donne une bonne base !

Je pense que je vais reprendre le bon vieux carnet d' adresse ( qui est en plus dans le tuto ) + les codes postaux.
puis j' essaierai de les coupler.
Le croisement des deux se fera, je pense, dans le formulaire de création des fiches du carnet d' adresses.

Pour te montrer ce qu'il faut faire pour faire cohabiter KGFdll et BDR.dll, voici mon exemple étendu:

Code:: ' demo_pour_Ygerinimi.bas

' L'exemple suvant montre comment définir une série de fichiers ISAM
' et les créer ou ouvrir automatiquement. Les paramétrages sont réalisés
' dans le code de la procédure, sous forme de DATA commentées.
ouvrir_fichiers()

' on peut faire cohabiter les fichiers ISAM avec une BDR. Voici ce qu'il
' faut pour initialiser cela.
dim BDR$ : BDR$ = "C:\Fichers\MaBase.dat" : ' chemin et nom complet du fichier BDR
ouvrir_BDR(BDR$)

end

' Cette sub ouvre les fichiers existants, ou les crée s'ils n'existent pas.
' Elle crée automatiquement le tableau IsamID%(..) avec autant de cellules que
' de fichiers définis. Ce tableau est rempli avec les identifiants des fichiers
' ISAM qui seront utilisés pour chaque accès à ces fichiers.
sub ouvrir_fichiers()
label creer_fichier, ouvrir_fichier : ' sous-programmes à usage interne !
' ici, créer une variable globale pour CHAQUE fichier ISAM, mais pas un tableau !
dim IsamID%(3) : ' faire un tableau avec un élément pour chaque fichier
dim_local nfic%, nchamp%, ncle%, nchampcle%
dim_local ific%, ichamp%, icle%, ichampcle%
dim_local def$, nom$, n%

' initialiser le système ISAM
res% = dll_call0("InitIsam")

' initialiser les variables de support pour chaque fichier ISAM:
' ATTENION:cette section doit être adapté au nombre réel des fichiers !
n% = res% = dll_call0("GetIsamIdentifierSize") : ' récupérer la taille des variables de support
' répéter les 4 lignes suivantes pour chaque fichier:
dim support_chevaux$
support_chevaux$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_chevaux$))
IsamID%(1) = res%
dim support_histo$
support_histo$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_histo$))
IsamID%(2) = res%
dim support_personnel$
support_personnel$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_personnel$))
IsamID%(3) = res%

' on définit 3 fichiers:
' chevaux
' champs:
' : 1 = nom du cheval = 40 caractères format A...A
' 2 = code du cheval = 8 caractères format 99999999
' 3 = date de naissance = 8 caractères format aaaammjj
' 4 = autre donnée = 20 caractères format A...A
' ... (4 champs, dans cet exemple)
' clés:
' 1 = nom du cheval = champ 1
' 2 = code du cheval = champ 2, clé unique
' historique_des_courses
' champs:
' 1 = code cheval = 8 caractères format 99999999
' 2 = nom de la course = 40 caractères format A...A
' 3 = date de la course = 8 caractères format aaaammjj
' 4 = code jockey = 8 caractères format 99999999
' 5 = place obtenue = 2 caractères format 99
' ... (5 champs, dans cet exemple)
' clés:
' 1 = historique cheval = champs 1 suivi de 3
' 2 = chronologie = champ 3
' 3 = historique jockey = champ 4 suivi de 3
' personnel
' champs:
' 1 = nom de l'employé = 40 caractères format A...A
' 2 = prénom = 40 caractères format A...A
' 3 = code employé = 8 caractères format 99999999
' 4 = type employé = 2 caractères formap 99 (jockey, lad, secrétaire, ...)
' 5 = date de naissance = 8 caractères format aaaammjj
' ... (5 champs, dans cet exemple)
' clés:
' 1 = par nom = champs 1 + 2
' 2 = code employé = champ 3, clé unique
'
' On va définir tous ces paramètres dans des DATA:
DATA 3 : ' nombre de fichiers définis dans cet exemple
' pour le premier fichier:
data "C:\Fichiers\chevaux" : ' nom ISAM du fichier (sans extension)
data 4 : ' nombre des champs
data 40,8,8,20 : ' liste des longueurs des champs
data 2 : ' nombre des clés
data 1,0 : ' première clé: 1 champ, doublons non interdits
data 1 : ' champ 1 pour la clé
data 1,1 : ' deuxième clé: 1 champ doublons interdits
data 2 : ' champ 2 pour la clé
' pour le deuxième fichier:
data "C:\Fichiers\historique_des_courses" : ' nom ISAM du fichier (sans extension)
data 5 : ' nombre des champs
data 8,40,8,8,2 : ' liste des longueurs des champs
data 3 : ' nombre des clés
data 2,0 : ' première clé; 2 champs, doublons non interdits
data 1,3 : ' champs 1 et 3 pour la clé
data 1,0 : ' deuxième clé; 1 champ, doublons non interdits
data 3 : ' champ 3 pour la clé
data 2,0 : ' troixième clé; 2 champs, doublons non interdits
data 4,3 : ' champs 4 et 3 pour la clé
' pour le troisième fichier:
data "C:\Fichiers\personnel" : ' nom ISAM du fichier (sans extension)
data 5 : ' nombre des champs
data 40,40,8,2,8 : ' liste des longueurs des champs
data 2,0 : ' première clé; 2 champs, doublons non interdits
data 1,2 : ' champs 1 et 2 pour la clé
data 1,1 : ' deuxième clé: 1 champ doublons interdits
data 3 : ' champ 3 pour la clé

read nfic% : ' prendre le nombre de fichiers
for ific%=1 to nfic% : ' boucle pour la définition d'un fichier
read nom$ : ' prendre le nom ISAM du fichier
res% = dll_call1("IsamFileExists",adr(nom$)) : ' tester si le fichier existe
if res%<0 : ' le fichier n'existe pas ?
gosub creer_fichier : ' alors le créer
else : ' sinon
gosub ouvrir_fichier : ' l'ouvrir
end_if
next ific%

exit_sub : ' fin de la phase d'ouverture

' sous-programme interne: créer un fichier ISAM
creer_fichier:
read nchamp% : ' prendre le nom de des champs
res% = dll_call2("CreateIsamFile",IsamID%(ific%),adr(nam$)) : ' créer un fichier vide

def$ = str$(nchamp%) : ' préparer le paramètre pour la création du fichier
for ichamp%=1 to nchamp% : ' boucle sur les champs
read n% : ' prendre la longueur d'un champ
def$ = def$ + "," + str$(n%) : ' et compléter la définition
next ichamp% : ' fin boucle sur les champs
res% = dll_call2("SetIsamFields",IsamID%(ific%),adr(def$)) : ' définir les champs

read ncle% : ' récupérer le nombre de clés pour le fichier
for icle%=1 to ncle% : ' boucle sur les clés
def$ = str$(ncle%) : ' initialiser la définition de la clé
read n% : ' lire l'indicateur d'unicité
def$ = def$ + "," + str$(n%)
read nchampcle% : ' récupérer le nombre de champs pour la clé
for ichampcle%=1 to nchampcle% : ' boucle sur les champs de la clé*
read d% : ' récupérer un numéro du champ de la clé
def$ = def$ + "," + str$(n%)
next ichampcle% : ' fin de boucle sur les champs de la clé
res% = dll_call2("SetIsamKeyFields",IsamID%(ific%),adr(def$)) : ' définir la clé
next icle% : ' fin de boucle sur les clés
return

' sous-programme interne: ouvrir un fichier ISAM
ouvrir_fichier:
res% = dll_call2("OpenIsamFile",IsamID%(ific%),adr(nom$)) : ' ouvrir un fichier ISAM existant
: ' maintenant, il fait dépasser les DATA inutiles pour ce fichier:
read nchamp% : ' prendre le nom de des champs

for ichamp%=1 to nchamp% : ' boucle sur les champs
read n% : ' prendre la longueur d'un champ
next ichamp% : ' fin boucle sur les champs

read ncle% : ' récupérer le nombre de clés pour le fichier
for icle%=1 to ncle% : ' boucle sur les clés
read n% : ' lire l'indicateur d'unicité
read nchampcle% : ' récupérer le nombre de champs pour la clé
for ichampcle%=1 to nchampcle% : ' boucle sur les champs de la clé*
read d% : ' récupérer un numéro du champ de la clé
next ichampcle% : ' fin de boucle sur les champs de la clé
next icle%
return

end_sub

' procédure pour initialiser le système BDR et l'utiliser en même temps
' que KGF.dll. Pour cela, il faut inclure BDR_SUB.bas en fin de programme
' et accéder la BDR par les SUBs de BDR_SUB.bas et non par les appels
' directs des fonctions de BDR.dll !
sub ouvrir_BDR(fic$)
BDRinitialize("BDR.dll") : ' initialisation de l'environnement BDR
BDRopen(fic$) : ' ouvertire de la base fe données
end_sub

' ceci est indispensable en fin de programme pour accéder BDR et KGF simultanément !
#INCLUDE "BDR_SUB.bas"

Cela tient compte du fait que Panoramic ne sait pas gérer plusieurs DLLs simultanément. Mais KGF.dll sait le faire ! Donc, on inclut BDR_SUB.bas dans le source du programme, de préférence à la fin du fichier. Puis, on ouvre KGF.dll. Ensuite, on utilise la SUB ouvrir_fichiers pour ouvrir ou créer tous les fichiers ISAM. Et finalement, on utilise la petite SUB ouvrir_BDR pour initialiser le système BDR et ouvrir la BDR.

A partir e là, on peut utiliser les fonctions KGF.dll pour accéder aux fichiers ISAM, et les SUBS de BDR_SUB (documentées dans BDR.chm) pour accéder directement aux fonctions de BDR.dll, bien que celles-ci se situent dans une autre DLL que KGF.dll. Mais c'est parfaitement transparent, et Panoramic n'en sait rien.

Merci Klaus,
Je vais classé cette page dans mes favoris pour y revenir plus facilement.

ygeronimi, je vais polluer le minimum possible: si tu fais ton programme de gestion d'écurie de courses pour bosser et que tu en ai content. Tu peux facilement en faire un jeu où le joueur doit gérer des chevaux avec des courses fictives... Ce serait le premier jeu de gestion que l'on aurait dans Panoramic... Bon, en attendant, il faut déjà que tu réussisse à tout mettre en place Wink

Bon courage mais pense à mon idée quand tu auras fini car tu auras fait la partie la plus difficile.

J'ai mis une nouvelle version de KGF.dll en ligne, avec une modification sur certaines fonctions ISAM. La doc est actualisée (CHM et doc en ligne sur les deux sites).

Voici le code exemple, adapté à la nouvelle version de KGF.dll. J'ai également ajouté une petite procédure qui montre comment on peut facilement créer un nouvel enregistrement (un cheval, en occurrence) et créer son entité BDR en même temps:

Code:: ' demo_pour_Ygerinimi.bas

' L'exemple suvant montre comment définir une série de fichiers ISAM
' et les créer ou ouvrir automatiquement. Les paramétrages sont réalisés
' dans le code de la procédure, sous forme de DATA commentées.
ouvrir_fichiers()

' on peut faire cohabiter les fichiers ISAM avec une BDR. Voici ce qu'il
' faut pour initialiser cela.
dim BDR$ : BDR$ = "C:\Fichers\MaBase.dat" : ' chemin et nom complet du fichier BDR
ouvrir_BDR(BDR$)

end

' quelques SUBs pour créer les nouveaux enregistrements
' créer un nouveau cheval
sub nouveau_cheval(nom$,code%,naissance$,autre$)
dim_local cd$, rec$, lrec%, fill$
cd$ = right$(string$(8,"0")+str$(code%),8) : ' construire ce code justifié à droite
lrec% = dll_call1("GetIsamRecordLength",IsamID%(1)) : ' récupérer la longueur d'enregistrement

rec$ = string$(lrec%," ") : ' préparer un enregistrement vide
fill$ = " " : ' caractère de remplissage
res% = dll_call6("FillIsamField",IsamID%(1),1,0,adr(rec$),adr(nom$),adr(fill$)) : ' remplir champ 1
fill$ = "0" : ' caractère de remplissage
res% = dll_call6("FillIsamField",IsamID%(1),2,1,adr(rec$),adr(cd$),adr(fill$)) : ' remplir champ 2
fill$ = " " : ' caractère de remplissage
res% = dll_call6("FillIsamField",IsamID%(1),3,0,adr(rec$),adr(naissance$),adr(fill$)) : ' remplir champ 3
fill$ = " " : ' caractère de remplissage
res% = dll_call6("FillIsamField",IsamID%(1),4,0,adr(rec$),adr(autre$),adr(fill$)) : ' remplir champ 4

res% = dll_call2("AddIsamRecord",IsamID%,adr(rec$)) : ' ajouter le nouvel enregistrement
' les clés sont générées automatiquement !
res% = dll_call0("GetIsamError")
if res%=10230
message "Oups... ce code cheval existe déjà - création impossible !"
exit_sub
end_if

' ici, ajouter l'entité du cheval dans la BDR
BDRadd("Cheval_"+cd$,"") : ' l'entité "cheval" est créée, sans données

end_sub

' Cette sub ouvre les fichiers existants, ou les crée s'ils n'existent pas.
' Elle crée automatiquement le tableau IsamID%(..) avec autant de cellules que
' de fichiers définis. Ce tableau est rempli avec les identifiants des fichiers
' ISAM qui seront utilisés pour chaque accès à ces fichiers.
sub ouvrir_fichiers()
label creer_fichier, ouvrir_fichier : ' sous-programmes à usage interne !
' ici, créer une variable globale pour CHAQUE fichier ISAM, mais pas un tableau !
dim IsamID%(3) : ' faire un tableau avec un élément pour chaque fichier
dim_local nfic%, nchamp%, ncle%, nchampcle%
dim_local ific%, ichamp%, icle%, ichampcle%
dim_local def$, nom$, n%

' initialiser le système ISAM
res% = dll_call0("InitIsam")

' initialiser les variables de support pour chaque fichier ISAM:
' ATTENION:cette section doit être adapté au nombre réel des fichiers !
n% = res% = dll_call0("GetIsamIdentifierSize") : ' récupérer la taille des variables de support
' répéter les 4 lignes suivantes pour chaque fichier:
dim support_chevaux$
support_chevaux$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_chevaux$))
IsamID%(1) = res%
dim support_histo$
support_histo$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_histo$))
IsamID%(2) = res%
dim support_personnel$
support_personnel$ = string$(n%," ")
res% = dll_call1("CreateIsamIdentifier",adr(support_personnel$))
IsamID%(3) = res%

' on définit 3 fichiers:
' chevaux
' champs:
' : 1 = nom du cheval = 40 caractères format A...A
' 2 = code du cheval = 8 caractères format 99999999
' 3 = date de naissance = 8 caractères format aaaammjj
' 4 = autre donnée = 20 caractères format A...A
' ... (4 champs, dans cet exemple)
' clés:
' 1 = nom du cheval = champ 1
' 2 = code du cheval = champ 2, clé unique
' historique_des_courses
' champs:
' 1 = code cheval = 8 caractères format 99999999
' 2 = nom de la course = 40 caractères format A...A
' 3 = date de la course = 8 caractères format aaaammjj
' 4 = code jockey = 8 caractères format 99999999
' 5 = place obtenue = 2 caractères format 99
' ... (5 champs, dans cet exemple)
' clés:
' 1 = historique cheval = champs 1 suivi de 3
' 2 = chronologie = champ 3
' 3 = historique jockey = champ 4 suivi de 3
' personnel
' champs:
' 1 = nom de l'employé = 40 caractères format A...A
' 2 = prénom = 40 caractères format A...A
' 3 = code employé = 8 caractères format 99999999
' 4 = type employé = 2 caractères formap 99 (jockey, lad, secrétaire, ...)
' 5 = date de naissance = 8 caractères format aaaammjj
' ... (5 champs, dans cet exemple)
' clés:
' 1 = par nom = champs 1 + 2
' 2 = code employé = champ 3, clé unique
'
' On va définir tous ces paramètres dans des DATA:
DATA 3 : ' nombre de fichiers définis dans cet exemple
' pour le premier fichier:
data "C:\Fichiers\chevaux" : ' nom ISAM du fichier (sans extension)
data 4 : ' nombre des champs
data 40,8,8,20 : ' liste des longueurs des champs
data 2 : ' nombre des clés
data 1,0 : ' première clé: 1 champ, doublons non interdits
data 1 : ' champ 1 pour la clé
data 1,1 : ' deuxième clé: 1 champ doublons interdits
data 2 : ' champ 2 pour la clé
' pour le deuxième fichier:
data "C:\Fichiers\historique_des_courses" : ' nom ISAM du fichier (sans extension)
data 5 : ' nombre des champs
data 8,40,8,8,2 : ' liste des longueurs des champs
data 3 : ' nombre des clés
data 2,0 : ' première clé; 2 champs, doublons non interdits
data 1,3 : ' champs 1 et 3 pour la clé
data 1,0 : ' deuxième clé; 1 champ, doublons non interdits
data 3 : ' champ 3 pour la clé
data 2,0 : ' troixième clé; 2 champs, doublons non interdits
data 4,3 : ' champs 4 et 3 pour la clé
' pour le troisième fichier:
data "C:\Fichiers\personnel" : ' nom ISAM du fichier (sans extension)
data 5 : ' nombre des champs
data 40,40,8,2,8 : ' liste des longueurs des champs
data 2,0 : ' première clé; 2 champs, doublons non interdits
data 1,2 : ' champs 1 et 2 pour la clé
data 1,1 : ' deuxième clé: 1 champ doublons interdits
data 3 : ' champ 3 pour la clé

read nfic% : ' prendre le nombre de fichiers
for ific%=1 to nfic% : ' boucle pour la définition d'un fichier
read nom$ : ' prendre le nom ISAM du fichier
res% = dll_call1("IsamFileExists",adr(nom$)) : ' tester si le fichier existe
if res%<0 : ' le fichier n'existe pas ?
gosub creer_fichier : ' alors le créer
else : ' sinon
gosub ouvrir_fichier : ' l'ouvrir
end_if
next ific%

exit_sub : ' fin de la phase d'ouverture

' sous-programme interne: créer un fichier ISAM
creer_fichier:
read nchamp% : ' prendre le nom de des champs
res% = dll_call2("CreateIsamFile",IsamID%(ific%),adr(nam$)) : ' créer un fichier vide

def$ = str$(nchamp%) : ' préparer le paramètre pour la création du fichier
for ichamp%=1 to nchamp% : ' boucle sur les champs
read n% : ' prendre la longueur d'un champ
def$ = def$ + "," + str$(n%) : ' et compléter la définition
next ichamp% : ' fin boucle sur les champs
res% = dll_call2("SetIsamFields",IsamID%(ific%),adr(def$)) : ' définir les champs

read ncle% : ' récupérer le nombre de clés pour le fichier
for icle%=1 to ncle% : ' boucle sur les clés
def$ = str$(ncle%) : ' initialiser la définition de la clé
read n% : ' lire l'indicateur d'unicité
def$ = def$ + "," + str$(n%)
read nchampcle% : ' récupérer le nombre de champs pour la clé
for ichampcle%=1 to nchampcle% : ' boucle sur les champs de la clé*
read d% : ' récupérer un numéro du champ de la clé
def$ = def$ + "," + str$(n%)
next ichampcle% : ' fin de boucle sur les champs de la clé
res% = dll_call2("SetIsamKeyFields",IsamID%(ific%),adr(def$)) : ' définir la clé
next icle% : ' fin de boucle sur les clés
return

' sous-programme interne: ouvrir un fichier ISAM
ouvrir_fichier:
res% = dll_call2("OpenIsamFile",IsamID%(ific%),adr(nom$)) : ' ouvrir un fichier ISAM existant
: ' maintenant, il fait dépasser les DATA inutiles pour ce fichier:
read nchamp% : ' prendre le nom de des champs

for ichamp%=1 to nchamp% : ' boucle sur les champs
read n% : ' prendre la longueur d'un champ
next ichamp% : ' fin boucle sur les champs

read ncle% : ' récupérer le nombre de clés pour le fichier
for icle%=1 to ncle% : ' boucle sur les clés
read n% : ' lire l'indicateur d'unicité
read nchampcle% : ' récupérer le nombre de champs pour la clé
for ichampcle%=1 to nchampcle% : ' boucle sur les champs de la clé*
read d% : ' récupérer un numéro du champ de la clé
next ichampcle% : ' fin de boucle sur les champs de la clé
next icle%
return

end_sub

' procédure pour initialiser le système BDR et l'utiliser en même temps
' que KGF.dll. Pour cela, il faut inclure BDR_SUB.bas en fin de programme
' et accéder la BDR par les SUBs de BDR_SUB.bas et non par les appels
' directs des fonctions de BDR.dll !
sub ouvrir_BDR(fic$)
BDRinitialize("BDR.dll") : ' initialisation de l'environnement BDR
BDRopen(fic$) : ' ouvertire de la base fe données
end_sub

' ceci est indispensable en fin de programme pour accéder BDR et KGF simultanément !
#INCLUDE "BDR_SUB.bas"

@ Jicehel,

Promis, j' y penserai, d' ici une vingtaine d' années... Laughing

@ Klaus,

Me revoilà mais entre temps tu as fait évoluer le bidule...
Bref, j' avais fait cette SUB mais j' ai pas de fichiers qui se crée... Crying or Very sad

Code:: SUB Init()
dim_local res%,support$,def$,defkey$

' activation de kgf
dll_on kgf$

' initialisation de l' environnement isam
res% = dll_call0("InitIsam")

' recup de le version isam
ISAM_vers$ = string$(25," ")
res% = dll_call1("GetIsamVersion",adr(ISAM_vers$))

' création de l' identifiant isam
ISAM_IdentSize% = dll_call0("GetIsamIdentifierSize")
support$ = string$(ISAM_IdentSize%," ")
ISAM_id% = dll_call1("CreateIsamIdentifier",adr(support$))

' vérif de l' existence de la base ou pas
ISAM_nam$ ="PhoneBook"
ISAM_exist% = dll_call1("IsamFileExists",adr(ISAM_nam$))

if ISAM_exist% <0
' création des champs
def$ ="5,100,150,10,10,200"
res% = dll_call2("SetIsamFields",Isam_ID%,adr(def$))
' création des cles
defkey$ ="1,1,1"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="2,0,2"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="3,1,3"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="4,1,4"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="5,1,5"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
res% = dll_call2("CreateIsamFile",Isam_ID%,adr(ISAM_nam$))
else
res% = dll_call2("OpenIsamFile",Isam_ID%,adr(ISAM_nam$))
end_if
END_SUB

Il y a deux problèmes:
1. la variable support$ et la variable Isam_ID% doivent être des variables globales, pas des variables locales d'une SUB (marqué en rouge dans la doc de la fonctioin CreateIsamIdentifier)
2. la longueur totale d'une clé ne peut dépasser 30 caractères (marqué en gras dans l'introduction aux fonctions ISAM, après le titre "Les restriction actuelles de cette implémentation sont:"

Voici la SUB partiellement corrigée et annotée:

Code:: dim kgf$ : kgf$ = "KGF.dll"
dim ISAM_vers$, res%
dim support$, Isam_ID% : ' <====== ces deux variables doivent être globales !
Init()

end

SUB Init()
dim_local res%,def$,defkey$, ISAM_IdentSize%, ISAM_exist%, ISAM_nam$

' activation de kgf
dll_on kgf$

' initialisation de l' environnement isam
res% = dll_call0("InitIsam")

' recup de le version isam
ISAM_vers$ = string$(25," ")
res% = dll_call1("GetIsamVersion",adr(ISAM_vers$))

' création de l' identifiant isam
ISAM_IdentSize% = dll_call0("GetIsamIdentifierSize")
support$ = string$(ISAM_IdentSize%," ")
Isam_ID% = dll_call1("CreateIsamIdentifier",adr(support$))

' vérif de l' existence de la base ou pas
ISAM_nam$ ="PhoneBook"
ISAM_exist% = dll_call1("IsamFileExists",adr(ISAM_nam$))
if ISAM_exist% <0
' création des champs
' def$ ="5,100,150,10,10,200"
def$ ="5,20,15,10,10,20" : ' <======== la création se passe bien avec ceslongueurs
res% = dll_call2("SetIsamFields",Isam_ID%,adr(def$))
' création des cles
defkey$ ="1,1,1" : ' champ trop long: "la longueur de chaque clé est limitée à 30 caractères"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="2,0,2" : ' champ trop long: "la longueur de chaque clé est limitée à 30 caractères"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="3,1,3"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="4,1,4"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
defkey$ ="5,1,5" : ' champ trop long: "la longueur de chaque clé est limitée à 30 caractères"
res% = dll_call2("SetIsamKeyFields",Isam_ID%,adr(defkey$))
res% = dll_call2("CreateIsamFile",Isam_ID%,adr(ISAM_nam$))
else
res% = dll_call2("OpenIsamFile",Isam_ID%,adr(ISAM_nam$))
end_if
END_SUB

Le problème de la longueur de la clé est ce qui empêche la création du fichier. Car, dès la première clé, la définition est rejetée (100 caractères de long...). Il n'y a donc pas encore de définition de clé valide qui soit mémorisée. Et en passant à la définition de la clé 2, le numéro de la clé (2) est trop grand (il devrait être 1, et la définition est donc rejetée. Et ainsi de suite. Et donc, la création du fichier à la fin est rejetée, car il n'y a aucune clé... J'ai donc mis des longueurs de champs fantaisistes, mais inférieurs à 30, et la création se passe bien.

Il faut que tu revoies la définition de ton enregistrement pour avoir des champs de telle sorte que la longueur totale de chaque clé soit inférieure ou égale à 30 caractères, quitte à avoir 2 champs: un champ long contenant l'information en clair, et un champ court contenant la valeur de la clé, éventuellement codée ou comprimée, à partir du champ complet.

Une technique classique pour résoudre le problème des clés longues, en particulier si les doublons sont interdits comme dans ton exemple, c'est de garder la zone longue comme simple zone d'information, et créer une zone plus courte de 30 caractères maxi, et utiliser celle-ci comme clé. Et cette zone courte sera chargée par les 30 premiers caractères de la zone longue, mais on autorise les doublons sur cette zone. C'est la technique que j'ai employé dans ma démo ville.bas qui utilise les 30 premiers caractères du nom de ville comme clé, mais affiche ensuite le nom long pour information.

Tu peux aussi "compacter" la clé par une SUB spécifique, comme ceci:

Code:: sub CompacterCle1(cle$,n%)
dim_local i%, c$, v%
if variable("cle1$")=0 then dim cle1$
cle1$ = ""
for i%=1 to len(cle$)
c$ = mid$(cle$,i%,1)
v% = asc(upper$(c$))
if instr(" -()/àéêëèîïôùûç",c$)=0 then cle1$ = cle1$ + c$ : ' éliminer certains caractères
ou
if (v%>64) and (v%<91) then cle1$ = cle1$ + c$ : ' ne prendre que les lettres, en majuscules
next i%
cle1$ = left$(cle1$,n%) : ' prendre les n% premiers caractères
end_sub

Tu vois qu'on supprime certains caractères, ou on ne prend que les lettres converties en majuscules, et on limite ensuite à n% caractères. On construit ainsi une clé qui sera valable dans tous les cas. Par précaution, on peut alors autoriser les doublons, et traiter dans l'application le cas des doublons sur la clé: On ne considère comme vrai doublon que els cas où le champ long est identique dans les deux enregistrements.

Voilà, c'est une technique que j'ai employé souvent, car pour des raisons de vitesse d'accès, il faut garder les clés le plus courtes possible. Pourquoi ? Parce que plus une clé est courte, plus on peut ranger de clés dans une page index, et moins on a de lectures de page index à faire pour parcourir l'index.

Voici un programme complet permettant de tester le "compactage" d'une clé:

Code:: label comp

edit 1 : top 1,10 : left 1,10 : width 1,300
button 2 : top 2,10 : left 2,320 : caption 2,"Compacter" : on_click 2,comp
alpha 3 : top 3,40 : left 3,10
end

comp:
CompacterCle1(text$(1),30)
caption 3,cle1$
return

sub CompacterCle1(cle$,n%)
dim_local i%, c$, v%
if variable("cle1$")=0 then dim cle1$
cle1$ = ""
for i%=1 to len(cle$)
c$ = upper$(mid$(cle$,i%,1))
v% = asc(c$)
' if instr(" -()/àéêëèîïôùûç",c$)=0 then cle1$ = cle1$ + c$ : ' éliminer certains caractères
' ou
if (v%>64) and (v%<91) then cle1$ = cle1$ + c$ : ' ne prendre que les lettres, en majuscules
next i%
cle1$ = left$(cle1$,n%) : ' prendre les n% premiers caractères
end_sub

Il faudra que tu adaptes la notion de "cle1$" à ton cas de figure. C'est juste une maquette.

Merci Klaus.

Je me disais bien que j' avais fait une bourde quelque part... Laughing

En ce moment, dur dur de ce concentrer chez moi, deux ados en vacances
c' est usant, énervant, bref on a envie de les .... Du coup j' ai zappé ces mises en garde... Embarassed

J' ai réduit la taille des clés et passé la variable "support$" de locale à globale
et tout est rentré dans l' ordre... Laughing

inbase% = dll_call1("GetIsamRecordCount",Isam_ID%)

la base est vide, le résultat devrait être 0 mais là....

Tu as oublié de mettre à jour pour la version KGF.dll V4.87 du 26/07/2015. C'est elle qui introduit ce paramètre pour cette fonction.

Je viens de passer à la version V4.88 du 27/07/2015, avec une amélioration pour SetIsamKeyFields. Profites-en pour prendre la dernière version, et ton problème sera réglé.

Ok Klaus.

Regardes ton article page 7/24 en pdf.
au 4 eme choix, tu utilise la même fonction pour créer les champs et les clés... Suspect

» PhoneBook ( ISAM Database )
» ISAM toujours ISAM
» Souci avec ISAM
» Mes aventures avec ISAM et Panoramic
» Petit souci avec ISAM