APi de tri (QLGSORT et QLGSRTIO)

BoTTom |   
 API de TRI
                        + QLGSORT 
 
 Cette APi permet de 1/ trier un buffer d'entrée (variable)
                              - vers un buffer de sortie
                              - vers un 1 à 32 fichier(s) de sortie
                              - avec sortie par groupe via QLGSRTIO
 
                     2/ trier 1 à 32 fichiers en entrée
                              - avec sortie vers 1 à 32 fichiers
                              - avec sortie vers buffer (variable)
                              - avec sortie par groupe via QLGSRTIO
 
                     3/ initialiser un tri,les entrées étant gérées
                          par groupe via appel(s) à QLGSRTIO
                              - avec sortie par groupe via la même API
                              - avec sortie dans 1 à 32 fichier(s)
 
 
 
 
 


|   
 
                      - CHAR(??) Request Control block
 
                                 (voir la structure plus loin)
 
                      - CHAR(??) buffer d'entrée       (pour tri type 4,5,6)
 
                      - CHAR(??) buffer de sortie      (pour tri type 2,5)
 
                      - BIN(4)   lg du buffer d'entrée
 
                      - BIN(4)   lg du buffer de sortie
 
                      - BIN(4)   lg des données retournées
                                 (si > à la lg du buffer de sortie les
                                  données ont été s tronquées)
 
                      - CHAR(??) code erreur
 
 
 
 


|   
 Le paramètre Request Control Block 
 
              - BIN(4) lg de ce paramètre
 
              - type de tri
                 ............Entrée................Sortie...................
                 :   1  :  fichier(s)           : fichier(s)               :
                 :   2  :  fichier(s)           : buffer de sortie         :
                 :   3  :  fichier(s)           : Appels à QLGSRTIO        :
                 :   4  :  buffer d'entrée      : fichier(s)               :
                 :   5  :  buffer d'entrée      : buffer de sortie         :
                 :   6  :  buffers d'entrée     : Appels à QLGSRTIO        :
                 :   7  :  Appels à QLGSRTIO    : fichier(s)               :
                 :   8  :  Appels à QLGSRTIO    : Appels à QLGSRTIO        :
                 :......:.......................:..........................:
 
              - BIN(4) réservé (doit être = 0)
              - BIN(4) options 0 = aucune
                               1 = 1 message dans la log par fichier de
                                     sortie indiquant le nombre d'enreg.
                               2 = éliminer les clés en double (dft=laisser)
)                              3 = options 1 + 2


|   
              - BIN(4) lg des enregistrements
                       (0 = QLGSORT assume lg du premier fichier en entrée)
 
              - BIn(4) nombre d'enregistrements (obligatoire)
 
              - BIN(4) offset (déplacement) pour atteindre la structure
                       de définition des clés
 
              - BIN(4) nombre de clés
 
              - BIN(4) offset pour la structure de définition du langage
 
              - BIN(4) offset pour atteindre la liste des fichiers en entrée
 
              - BIN(4) nombre de fichiers en entrée
 
              - BIN(4) offset pour atteindre la liste des fichiers en sortie
 
              - BIN(4) nombre de fichiers en sortie
 
              - BIN(4) réservé (doit être = 0)
 


|   
        - CHAR(??) définition des clés : x fois la structure suivante :
 
                   . BIN(4) début de la clé
 
                   . BIN(4) lg de la clé
 
                   . BIN(4) type de zone   0 = Binaire
                      1 = Scientifique                13 = date MM/DD/YY
                      2 = étendue                     14 = date DD/MM/YY
                      3 = packée                      15 = date DD.MM.YYYY
                      4 = charactère                  16 = date DD/MM/YYYY
                      5 = charactère (DBCS)           17 = date et heure
                      6 = Charactère sans notion            autres fmt
                           de langage                 18 = Heure HH:MM xx
                      7 = Packé non signé                   xx = AM ou PM
                      8 = étendue non signé
                      9 = binaire non signé
                     10 = étendue avec +/- hors texte
                     11 = étendue avec +/- à droite
                     12 = étendue avec +/- à gauche
 
                   . BIN(4) ordre, 1 = croissant / 2 = décroissant


|   
 
        - CHAR(290) table de tri
 
                   . CHAR(20) table de tri qualifiée   ou
                                *JOB,*JOBRUN = celle du job
                                *LANGIDUNQ   = celle du langage
                                                (poids unique)
                                *LANGIDSHR   = celle du langage
                                                (poids partagés)
                                *HEX         = EBCIDC
                                *TABLE       = la table fournie en
                                                quatrième élément
 
                   . BIN(4) CCSID       0 = celui du job
 
                   . CHAR(10) ID langage ou
                                *JOB,*JOBRUN = celui du job
 
                   . CHAR(256) source d'une table de tri si *TABLE
 
 
 


|   
 
        - CHAR(??) Liste des fichiers en entrée
                   x fois la structure suivante:
 
                   . CHAR(20)  nom qualifié d'un fichier d'entrée
 
                   . CHAR(10)  nom du membre
 
        - CHAR(??) Liste des fichiers en sortie
                   x fois la structure suivante:
 
                   . CHAR(20)  nom qualifié d'un fichier de sortie
 
                   . CHAR(10)  nom du membre
 
 
 
 
 
 
 
 


|   
                        + QLGSRTIO 
 
 permet de traiter des groupes d'enregistrements suite à un tri
  initialisé par QLGSORT (appel à cette API préalable obligatoire)
 
                           1/ en entrée
                              avec tri et sortie fichier
                              avec tri et sortie par groupe via la même API
                           2/ en sortie
                              suite à une entrée fichier
                              suite à des entrées par groupe via la même API
 
 
 pour utiliser cette API en entrée et en sortie vous devez:
 
 1/ définir les critères de tri avec QLGSORT
 2/ appeller x fois QLGSRTIO avec demande type 1 (ajout) en lui passant
     un groupe d'enregistrement à chaque appel
 3/ appeller une fois QLGSRTIO avec demande 2 (le tri est réalisé)
 4/ appeler x fois QLGSRTIO avec demande type 3 (extraction), cette api
    vous renvoi un groupe d'enregsitrement à chaque appel.
 


|   
 Paramètres:
                      - CHAR(??) Request Control block
                        . BIN(4) type de demande 1 = ajout
                                                 2 = arret d'ajout (tri)
                                                 3 = lecture
                                                 4 = annulation du tri
                        . BIn(4) réservé
                        . BIN(4) lg de chaque enregistrement
                        . BIN(4) nbr d'enregistrements (type 1)
                                 nbr maxi d'enregistrements (type 3)
 
                      - CHAR(??) buffer d'entrée       (demande type 1)
                      - CHAR(??) buffer de sortie      (demande type 3)
 
                      - BIN(4)   lg du buffer d'entrée
                      - BIN(4)   lg du buffer de sortie
 
                      - CHAR(16) informations en retour
                                 . BIN(4) nbr d'enreg. traités
                                 . BIN(4) nbr d'enreg disponibles
                                 . CHAR(8) réservé
                      - CHAR(??) code erreur





©AF400