4D v11 SQL Assimilator Résumé 4D Notes techniquesdownload.4d.com/Notes_Techniques/NT/2009/200909-17-4Dv11... · 2013-02-21 · 4D v11 SQL Assimilator Par Charles VASS, membre de

4D v11 SQL AssimilatorPar Charles VASS, membre de l’équipe des services techniques, 4D Inc.Note technique 4D-200909-17-FR

Version 1 - Date 1 septembre 2009

RésuméLe composant4D v11 SQL Assimilator permetaux développeursde migrer facilementet rapidementdesbasesexistantesvers une base4D v11 SQL hôte. L’utilisation du composantest simple, quelquesclicssuffisent à intégrer une base externe à l’intérieur d’une base 4D v11 SQL.4D v11Assimilatorestun composant4D v11 SQL qui permetau développeur4D declonerles tableset desynchroniserlesdonnéesdetouteunesériedebasesdedonnéesSQL externesdansunebasededonnées4D,qu’elle soit existante ou à créer.

4D Notes techniquesCopyright © 1985-2009 4D SAS - Tous droits réservés

Tous les efforts ont été faits pour que le contenu de cette note technique présente le maximum de fiabilité possible.Néanmoins, les différents éléments composant cette note technique, et le cas échéant, le code, sont fournis sans garantie d'aucune sorte.L'auteuret 4D S.A. déclinentdonc toute responsabilitéquantà l'utilisation qui pourrait être faite de ces éléments,tant à l'égard de leursutilisateurs que des tiers.

Lesinformationscontenuesdanscedocumentpeuventfaire l'objet de modificationssanspréaviset ne sauraienten aucunemanièreengager4DSA. La fournituredu logiciel décritdanscedocumentestrégiepar un octroi de licencedont les termessontpréciséspar ailleursdansla licenceélectroniquefigurantsurle supportduLogiciel etdela Documentationafférente.Le logiciel et sadocumentationne peuventêtreutilisés, copiésou reproduits sur quelque support que ce soit et de quelque manière que ce soit, que conformément aux termes de cette licence.Aucunepartiede ce documentne peutêtrereproduiteou recopiéede quelquemanièrequece soit, électroniqueou mécanique,y comprisparphotocopie,enregistrement,archivageou toutautreprocédéde stockage,de traitementet de récupérationd'informations,pour d'autresbuts quel'usage personnel de l'acheteur, et ce exclusivement aux conditions contractuelles, sans la permission explicite de 4D SA.4D, 4D Calc,4D Draw,4D Write,4D Insider,4ème Dimension®, 4D Server,4D Compilerainsi queles logos4e Dimension,sontdesmarquesenregistrées de 4D SA.Windows,Windows NT,Win 32s et Microsoft sont des marques enregistrées de Microsoft Corporation.Apple,Macintosh,PowerMacintosh,LaserWriter,ImageWriter,QuickTimesontdesmarquesenregistréesou desnomscommerciauxde AppleComputer,Inc.Mac2Win Software Copyright © 1990-2002 est un produit de Altura Software,Inc.4D Write contient des éléments de "MacLink Plus file translation", un produit de DataViz, Inc,55 Corporate drive,Trumbull,CT,USA.XTND Copyright 1992-2002 © 4D SA. Tous droits réservés.XTND TechnologyCopyright1989-2002© Claris Corporation..Tousdroits réservésACROBAT © Copyright1987-2002,SecretCommercialAdobe Systems Inc.Tous droits réservés. ACROBAT est une marque enregistrée d'Adobe Systems Inc.

Tous les autres noms de produits ou appellations sont des marques déposées ou des noms commerciaux appartenant à leurs propriétairesrespectifs.

1 / 36

4D v11 SQL Assimilator

Introduction

4D v11 Assimilator est un composant 4D v11 SQL qui permet au développeur 4D de cloner les tables et desynchroniser les données de toute une série de bases de données SQL externes dans une base de données 4Dqu'elle soit existante ou à créer. Tout comme les versions antérieures, cette version de Assimilator est conçupour permettre au développeur de recréer facilement la structure d'une base de données et d'en récupérer lesdonnées.

Sans avoir besoin de coder dans la base hôte, le composant Assimilator importera tables et données de SQLServer 2000, MySQL 5, Microsoft Access et autres bases 4D v11 SQL.

Dans le cas de 4D v11 SQL Server, le composant Assimilator communique directement sans recourir à undriver ODBC. Dans les autres cas, incluant les bases 4D monoposte, il faudra vous procurer le driver ODBCadéquat.

En l'état actuel, le composant Assimilator ne prend en charge qu'un nombre limité de bases de donnéestierces (4D, MySql, Ms SQL Server). La manière d'extraire les définitions de structure des différentsvendeurs est la même, seules les conventions de nommage des tables systèmes changent ; les développeurspeuvent facilement intégrer le code nécessaire au traitement de bases SQL non incluses dans la présenteversion.

Le composant 4D v11 SQL Assimilator

Les anciennes versions de 4D Assimilator utilisaient le plugin 4D ODBC ou le plugin 4D ODBC Pro. Avec4D v11 SQL, Assimilator n'utilise plus ces plugins mais passe directement par des commandes SQL natives.Cependant, l'utilisation de pilotes ODBC reste nécessaire: 4D v11 SQL reste dépendant du DSN (DataSource Name) pour communiquer avec toutes les bases externes à l'exception de 4D v11 SQL Server. Eneffet toutes les communications vers des bases externes, y compris 4D Stand-Alone, passent par les couchesde communication d'ODBC.

Le grand intérêt du composant Assimilator est sa souplesse qui autorise des tests rapides avant mise enœuvre finale. Créez une base de données 4D hôte, testez, affinez, puis déplacez le composant vers votreapplication finale et assimilez. Assimilator n'ajoute pasde nouvelles méthodes à la base hôte et quand letravail de clonage est terminé vous pouvez retirer le composant de la base.

Avant de commencer

Voici ce dont vous aurez besoin pour :

Assimiler une base de données SQL d'un vendeur " externe "

• Le pilote ODBC adéquat• Un utilisateur ou un DSN vers la base externe• Un Identifiant et mot de passe pour accéder à la base

• Les droits minimaux pour accéder au système de tables de la base à cloner

Assimiler un fichier de données 4D antérieur à la v11

Le traitement d'une base 4D qui n'a pas été converti vers 4D v11 SQL dépend de la plateforme sur laquelletourne votre base hôte.

Windows

• Le pilote 4D ODBC pour 4D Server doit obligatoirement être installé• Un utilisateur ou un DSN utilisant le pilote 4D ODBC• Un Identifiant et mot de passe

Macintosh

• Un pilote ODBC tiers• Un utilisateur ou un DSN utilisant le driver 4D ODBC• Un Identifiant et mot de passe

Assimiler une base de données 4D v11 SQL

Les outils nécessaires pour assimiler une base de données v11 dépendent du type de moteur qu'elle utilise.Assimiler une base tournant sur 4D v11 SQL Server ne demande presque rien car tout se passe en direct,sans recours aux couches ODBC. Cependant vous restez libre de passer par ODBC.

Le schéma ci-dessous décrit les canaux de communication SQL :

Assimiler une base v11 SQL Server sans ODBC

• Un nom d'utilisateur et un mot de passe• Un nom de publication sur le réseau ou l'adresse IP du serveur• Le port écouté par le serveur si différent du port par défaut (19182)

Assimiler une base v11 SQL monoposte ou Server avec ODBC

3 / 36

• Le driver ODBC 4D v11 SQL fourni par 4D• Un utilisateur ou un DSN utilisant le driver 4D ODBC• Un utilisateur et un mot de passe pour l'application• Les droits d'accès minimum pour accéder aux tables système

Avertissements

Certaines bases de données autorisent l'utilisation de caractères spéciaux dans le nom des tables et descolonnes ; 4D v11 SQL en fait partie. Cependant lors de l'importation des données directement dans deschamps, ces caractères spéciaux peuvent perturber le bon fonctionnement du moteur SQL de 4D. Voici uneliste non exhaustive de ces caractères :

/ \ | ~ # % ^ & * ( ) - + = ' “ ”

Si vous assimilez une base de données utilisant un ou plusieurs de ces caractères dans les noms de tables oude colonnes, il faudra renommer ces tables ou ces colonnes dans votre structure 4D afin d'éliminer cescaractères spéciaux.

Certains types de données ne sont pas totalement transposables dans une base 4D. Par exemple on retrouvedans des bases MySQL des champs de type " ENUM " qui pourraient être comparés à un champ 4D quiaccepterait des valeurs d'une liste 4D. Ces champs peuvent contenir toute une variété de données : desalphanumériques, des numériques, des booléens, etc. Lorsde l'assimilation, leur taille sera adaptée à l'item leplus grand.

Par défaut Assimilator transpose le type ENUM en un alphanumérique de la longueur paramétrée dans lacolonne character_maximum_lengthde la table INFORMATION_SCHEMA COLUMNS (Dans MySQL, latable COLUMNS fournit des informations sur les colonnes dans les tables.)

Nouveautés de la version 4D v11 SQL Assimilator

Tel que mentionné plus haut, 4D v11 SQL Assimilator n'utilise plus que les commandes SQL 4D natives,alors que dans les versions précédentes tout transitait par le protocole ODBC.Utiliser les commandes natives met en lumière la difficultéque représente la lecture des tables systèmes dechacun des vendeurs de solutions tierces. En relevant ce défi, 4D v11 SQL Assimilator met en avant lapuissance et la souplesse du langage SQL natif de 4D et peut être utilisé aussi bien comme un outil deproductivité qu'un outil de formation.

Le fonctionnement de 4D v11 SQL Assimilator

Dans le composant Assimilator, une seule méthode est partagée avec sa base hôte. Cette méthode estASS_OpenConnection. Les autres méthodes sont privées et préfixées selon leurs usages. Tout ce quiconcerne le travail d'assimilation est préfixéASS_. Les autres méthodes ne seront pas décrites dans cettenote car sans intérêt pour la bonne compréhension du composant. Voyons les méthodes qui sont mises enœuvre pour exploiter le langage SQL de 4D.

ASS_OpenConnection

Dans la méthodeASS_OpenConnection,Assimilator crée un nouveau process et appelleAss_Init_ProcVarsqui déclare toutes les variables process utilisées par le composant. Ensuite laméthode ouvre le dialogue " Connection_d " qui présente tous les choix et champs requis pour ouvrirune connexion vers la base de données à cloner.

Si l'utilisateur choisit de se connecter à une base externe,on exécute une des méthodes de la sérieAss_GetTableList_xxx. On trouvera dans ces méthodes la commandeSELECT propre à chaquesystème de tables de chaque vendeur.

Enfin la méthodeASS_OpenAssimilatorest appelée afin de présenter les outils nécessaires au clonagede la base externe vers la base hôte.

La méthode suivante est appelée depuis le dialogue de connexion :

ASS_GetDataSourceList

La méthodeASS_GetDataSourceListrécupère la liste desData Source Name(DSN) du système et del'utilisateur. Dans le cas de serveurs qui gèrent plusieursbases de données en même temps, il incombeau développeur de configurer le nom duDSN de telle sorte que Assimilator puisse identifier la base àassimiler. ActuellementASS_GetDataSourceListest codée pour parser (analyser) les noms deDSNrenvoyés par la commandeLISTE SOURCES DONNEES qui utilise " : " comme séparateur dedonnées entre le nom du DSN et le nom de la base de données, < DSN Titre > : < Base nom >.

LISTE SOURCES DONNEES(Source de données Système ;$SystemDSN_aT;$SystemDrvr_aT)

$SOA:=Taille tableau ($SystemDSN_aT)

LISTE SOURCES DONNEES(Source de données utilisateur ;$UserDSN_aT;$UserDrvr_aT)$RIS:=Taille tableau ($UserDSN_aT)

TABLEAU TEXTE(DSName_aT;$SOA+$RIS)TABLEAU TEXTE(DSDriver_aT;$SOA+$RIS)TABLEAU TEXTE(DSDBases_aT;$SOA+$RIS)

Si ($SOA>0)Boucle ($Ndx;1;$SOA)

DSName_aT{$Ndx}:=$SystemDSN_aT{$Ndx}DSDriver_aT{$Ndx}:=$SystemDrvr_aT{$Ndx}Si (Position (":";$SystemDSN_aT{$Ndx})>0)

DSDBases_aT{$Ndx}:=Sous chaine( $SystemDSN_aT{$Ndx};Position (":";$SystemDSN_aT{$Ndx})+1)

Sinon DSDBases_aT{$Ndx}:=""

Fin de si Fin de boucle

Fin de si

Si ($RIS>0)Boucle ($Ndx;1;$RIS)

DSName_aT{$Ndx+$SOA}:=$UserDSN_aT{$Ndx}DSDriver_aT{$Ndx+$SOA}:=$UserDrvr_aT{$Ndx}Si (Position (":";$UserDSN_aT{$Ndx})>0)

DSDBases_aT{$Ndx+$SOA}:=Sous chaine( ($UserDSN_aT{$Ndx};Position (":";$UserDSN_aT{$Ndx})+1)

Sinon

5 / 36

DSDBases_aT{$Ndx+$SOA}:=""Fin de si

Fin de boucle Fin de si

`======================== Nettoyage et sortie =================================

TRIER TABLEAU (DSName_aT;DSDriver_aT;DSDBases_aT)

Même si la documentation de la commandeLISTE SOURCES DONNEES indique des tableaux detype texte pour les deux arguments, il y a une limite de 33 caractères pour le 1er paramètretypeSource. Par conséquent si vous comptez utiliser la technique consistant à imbriquer le nom de labase dans le titre du DSN, vous vous limiterez à 33 caractères maximum.

Si vous n'utilisez pas la technique, entrez manuellement lenom de la base dans le champ approprié dudialogue de connexion.

Note : pour certains pilotes ODBC, le nommage du DSN est limité aux chiffres et aux lettres ; le pilotePostgreSQL en est un exemple. Si vous utilisez un driver de cetype, il faudra adapter à votre situationcertaines des conventions de cette Note technique ou bien saisir manuellement le nom de la base de donnéestel qu'expliqué précédemment.

A la sortie du dialogue de connexion, via le bouton " Connect ", les méthodes suivantes sont exécutées.

ASS_SQL_Login

Dans la méthodeASS_SQL_Loginprend en charge les trois alternatives possibles pourSQL LOGINde se connecter à 4D, Server ou monoposte.

`...

Si (vDBVendor_T="4D v11 SQL Server")Si (RB_4D=1)

SQL LOGIN("4D:"+vPublicationName_T;vUsername_T;vPassword_T;*)Sinon

SQL LOGIN("IP:"+vIPAddress_T;vUsername_T;vPassword_T;*)Fin de si

Sinon SQL LOGIN("ODBC:"+vDatasource_T;vUsername_T;vPassword_T;*)

Fin de si

`======================== Nettoyage et sortie =================================

Si (OK=1)$0:=DTS_GetISODateTimeStamp

Sinon $0:=""

Fin de si

`...

Notons qu'en cas de connexion, Assimilator crée une référence ; il ne se contente pas de simplement seréférer à la variable OK de 4D.

Dans la mesure oùASS_SQL_Logoutgénérera une erreur si la commande est appelée alors que 4Dn'est pas connecté, tester cette référence est une manière de parer à cette situation. La méthodeDTS_GetISODateTimeStamp retourne la référence utilisée par Asssimilator.

ASS_SQL_Logout

Lors de l'exécution de la méthodelASS_SQL_Logout, une variable processvSQL_Ref_A19est testée.Si ce n'est pas une chaîne vide, ASS_SQL_Logout est exécutée puis la variable est nettoyée.

Les méthodes préfixéesASS_GetTableListsont destinées à l'analyse des bases de données des différentsvendeurs présents sur le marché, y compris 4D v11 SQL. Chaquevendeur possède son propre système detables système pour documenter les tables et champs de sa base de données.Même si chaque vendeur a sa propre façon de faire, la technique permettant d'accéder aux tables etd'organiser les tableaux locaux qui donnent le choix des tables et champs à assimiler est toujours la même.Un développeur connaissant l'organisation des tables système d'une base SQL quelconque pourra facilementl'ajouter au composant en s'inspirant des méthodes ASS_GetTableList .

Les vuesINFORMATION_SCHEMA (ou tables Système) font partie du standard SQL-92 et sont prises encharge par bon nombre de bases de données. Les vues SQL ne sontà ce jour pas prises en charge par 4Dv11.4; cependant les tables système existent bien en 4D v11 SQL et sont utilisées dans cette Note technique.

INFORMATION_SCHEMA est une base de données virtuelle, vous ne pouvez y accéder qu'en lecture. Eneffet, les tables qui la composent, ne sont en fait que des vues. La baseINFORMATION_SCHEMA fournitdes métadonnées sur les tables, les champs, et d'autres parties de la base de données. Comme la structure deces tables est standardisée, les requêtes SQL sont valides sur la plupart des plateformes de bases de données.

Imaginons que vous vouliez récupérer la liste de tous les champs d'une table "employees" :

SELECT table_name, column_name, is_nullable, data_type , character_maximum_lengthFROM INFORMATION_SCHEMA.ColumnsWHERE table_name = 'employees'

C'est une requête simple et basique. Elle est utilisée avec quelques variantes dans cette Note technique. LesvuesINFORMATION_SCHEMA ne sont pas tout le temps disponibles et pas implémentées de manièreuniforme parmi les différents produits disponibles sur le marché. De plus il peut s'avérer difficile de trouverquelles versions de quels éditeurs prennent en charge les vues INFORMATION_SCHEMA et depuisquand. Voici une liste succincte des compatibilités:

Microsoft SQL Server — prise en charge Version 7 et plusMySQL — prise en charge Version 5 et plusPostgreSQL — prise en charge Version 7.4 et plus

Les vues INFORMATION_SCHEMA utilisables dans les bases listées ci-dessus sont décrites ci-dessous :

7 / 36

• INFORMATION_SCHEMA.SCHEMATA• INFORMATION_SCHEMA.TABLES• INFORMATION_SCHEMA.COLUMNS• INFORMATION_SCHEMA.STATISTICS• INFORMATION_SCHEMA.USER_PRIVILEGES• INFORMATION_SCHEMA.SCHEMA_PRIVILEGES• INFORMATION_SCHEMA.TABLE_PRIVILEGES• INFORMATION_SCHEMA.COLUMN_PRIVILEGES• INFORMATION_SCHEMA.CHARACTER_SETS• INFORMATION_SCHEMA.COLLATIONS• INFORMATION_SCHEMA.COLLATION_CHARACTER_SET_APPLICABILITY• INFORMATION_SCHEMA.TABLE_CONSTRAINTS• INFORMATION_SCHEMA.KEY_COLUMN_USAGE• INFORMATION_SCHEMA.ROUTINES• INFORMATION_SCHEMA.VIEWS• INFORMATION_SCHEMA.TRIGGERS• INFORMATION_SCHEMA.PROFILING

4D v11 SQL ne prend pas en chargeINFORMATION_SCHEMA dans la forme qui vient d'être citée. Sonsystème de table est :

_USER_TABLES_USER_COLUMNS_USER_INDEXES_USER_CONSTRAINTS_USER_IND_COLUMNS_USER _CONS_ COLUMNS_USER_SCHEMAS

Quant aux noms des tables, tous les vendeurs n'ont pas les mêmes restrictions que 4D v11 SQL. Par exempleil est parfaitement possible d'avoir une table MySQL qui se nommerait "transaction". 4D v11 SQL retourneraune erreur si vous tentez d'assimiler une telle table. Pour ne pas être confronté au problème, une liste desnoms réservés accompagne cette Note technique. En cas de rencontre malheureuse avec un de ces nomsréservés, une alerte vous sera présentée afin de renommer latable. Au cas où un nom réservé apparaîtraitsans que vous en soyez alerté il sera possible d'ajouter ce nom à la liste des " réservés ".

ASS_GetTableList_4Dv11

La méthodeASS_GetTableList_4Dv11lit la table _USER_COLUMNS de la base 4D sur laquellevous êtes connecté :

vSQL_Ref_A19:=ASS_SQL_Login

Si (vSQL_Ref_A19#"")

`======================== Actions methode ==================================

Debut SQLSELECT TABLE_NAME, COLUMN_NAME, OLD_DATA_TYPE, DATA_LENGTHFROM _USER_COLUMNSINTO :Src_Table_aT, :Src_Column_aT, :Src_Type_aL, :Src_Size_aL;

Fin SQL

$SOA:=Taille tableau (Src_Type_aL)TABLEAU TEXTE(Src_Type_aT;$SOA)Boucle ($Ndx;1;$SOA)

Src_Type_aT{$Ndx}:=ASS_TranslateType_4DToSQL (Src_Type_aL{$Ndx})Si (Src_Type_aL{$Ndx}=Est un champ alpha )

Src_Size_aL{$Ndx}:=(Src_Size_aL{$Ndx}-4)/2Fin de si

Fin de boucle

ARR_Distinct (->Src_Table_aT;->Ass_TableList_aT)$SOA:=Taille tableau (Ass_TableList_aT)TABLEAU BOOLEEN (Ass_SelectedTable_aB;$SOA)TABLEAU ENTIER LONG(Ass_TableSize_aL;$SOA)TABLEAU ENTIER LONG(Ass_RowCount_aL;$SOA)

C_ENTIER LONG($Type_L;$Size_L;$Jdx;$Idx;$Sdx;$Cnt_L)Boucle ($Ndx;1;$SOA)

$Cnt_L:=Compter dans tableau (Src_Table_aT;Ass_TableList_aT{$Ndx})$Sdx:=Chercher dans tableau (Src_Table_aT;Ass_TableList_aT{$Ndx})

$Size_L:=0Boucle ($Jdx;$Sdx;($Cnt_L+$Sdx)-1)

$Size_L:=$Size_L+ASS_4DStorageSpace (Src_Type_aT{$Jdx};Src_Size_aL{$Jdx})Fin de boucle

Ass_TableSize_aL{$Ndx}:=$Size_LSi (Ass_TableList_aT{$Ndx}#"Deleted@")

Ass_RowCount_aL{$Ndx}:=ASS_GetRowCount (Ass_TableList_aT{$Ndx})Fin de si

Fin de boucle

`======================== Nettoyage et sortie ==============================

ASS_SQL_Logout

Fin de si

Les tableauxSrc_Table_aT, Src_Column_aT, Src_Type_aL et Src_Size_aLsont prédéfinis dans laméthode compiler _App appelée lors du lancement du process ASS_OpenConnection.

Notez qu'il y a un nom de colonne dans le SELECT qui ne se trouvepas dans la documentation de 4D.Les valeurs stockées dans la colonneDATA_TYPE ne sont pas dans le thème des constantes pour lestypes de champs et de variables. Pour avoir ces valeurs il faudra se rendre dans le thèmeOLD_DATA_TYPE .Là où des produits tels que MySQL et SQL server retournent unechaîne pour définir le type descolonnes, 4D retourne un entier qu'Assimilator transcrit au format SQL. La méthodeASS_TranslateType_4DToSQL réalise ce travail.Dans le tableauSrc_Size_aL, 4D ne retourne pas la taille SQL des champs VARCHAR mais l'espaceque va occuper le champ dans la base de données. Cette valeur est calculée sur la base de 2 octets parcaractère plus 4 octets pour la longueur de la chaîne. Pour retrouver la taille traditionnelle du champalpha, la valeur contenue dans l'élément du tableau est réduite de 4 puis divisée par 2.

9 / 36

ASS_TranslateType_4DToSQL

Vous trouverez ci-dessous, la méthode utilisée pour transposer les constantes 4D vers des types SQL.On sait que, dans certains cas, 4D retourne la valeur -1 pour les champs BLOB et les sous-tablesconverties. Dans cette méthode la valeur -1 est présumée représenter une sous-table convertie.

Au cas ou

: ($1=Est un entier long )$0:="INT"

: ($1=Est un entier )$0:="SMALLINT"

: ($1=Est un champ alpha )$0:="VARCHAR"

: ($1=Est un booléen )$0:="BOOLEAN"

: (($1=Est un numérique ) | ($1=Est un float ))$0:="REAL"

: ($1=Est une date )$0:="DATE"

: ($1=Est une heure )$0:="TIME"

: ($1=Est un BLOB )$0:="BLOB

: ($1=Est un texte )$0:="TEXT"

: (($1=Est une sous table ) | ($1=-1))$0:="SUBTABLE"

: ($1=Est un entier 64 bits )$0:="NUMERIC"

: ($1=Est une image )$0:="PICTURE"

: ($1=Est un pointeur )$0:="POINTER"

: ($1=Est une variable chaîne )$0:="CHAR"

: ($1=Est une variable indéfinie )$0:="UNDEFINED"

Sinon

Mssg ("ALERT";"Type de données non reconnu";Chaine ($1))

Fin de cas

ASS_GetTableList_MySQL

La méthode ASS_GetTableList_MySQL effectue une requête sur la table systèmeINFOMATION_SCHEMA.COLUMNS de la base identifiée par la variable processvDatabase_T ;l'objectif de cette requête est de récupérer la liste des tables et des colonnes.

On notera une légère différence par rapport à la requête évoquée plus haut dans cette Note technique,MySQL 5 utilisant le nom de colonne “table_schema” au lieu de “table_name”.

A l'exception de 4D V11 SQL, on constate que les requêtes sur les tables système ne retournent que lataille des colonnesVARCHAR dans le tableau “Src_Size_aL”. Une boucle permet de garder lestableaux synchronisés en insérant un élément vide lorsque la requête ne retourne pas une colonne detype VARCHAR .


Si (vSQL_Ref_A19#"")Debut SQL

SELECT table_name, column_name, data_type, character_maximum_lengthFROM INFORMATION_SCHEMA.COLUMNSWHERE table_schema = :vDatabase_TINTO :Src_Table_aT, :Src_Column_aT, :Src_Type_aT, :Src_Size_aL;

Fin SQL

`// On ajuste le tableau Src_Size_L sur le tableau Src_Type_aT $Idx:=0$SOA:=Taille tableau (Src_Type_aT)Boucle ($Ndx;1;$SOA)

$Idx:=$Idx+1Src_Type_aT{$Ndx}:=Majusc (Src_Type_aT{$Ndx})$Type_L:=ASS_TranslateType_SQLTo4D (Src_Type_aT{$Ndx})Au cas ou

: (($Type_L=Est un texte ) | ($Type_L=Est un champ alpha ))Sinon

INSERER DANS TABLEAU (Src_Size_aL;$Idx)Src_Size_aL{$Idx}:=ASS_4DSizeFromSQLType (Src_Type_aT{$Idx})

Fin de cas Fin de boucle

`======================== Actions methode ===============================

ARR_Distinct (->Src_Table_aT;->Ass_TableList_aT)$SOA:=Taille tableau (Ass_TableList_aT)TABLEAU BOOLEEN (Ass_SelectedTable_aB;$SOA)TABLEAU ENTIER LONG(Ass_TableSize_aL;$SOA)TABLEAU ENTIER LONG(Ass_RowCount_aL;$SOA)

Boucle ($Ndx;1;$SOA)$Cnt_L:=Compter dans tableau (Src_Table_aT;Ass_TableList_aT{$Ndx})$Sdx:=Chercher dans tableau (Src_Table_aT;Ass_TableList_aT{$Ndx})



Ass_TableSize_aL{$Ndx}:=$Size_LAss_RowCount_aL{$Ndx}:=ASS_GetRowCount (Ass_TableList_aT{$Ndx})

Fin de boucle


ASS_SQL_Logout

Fin de si

11 / 36

ASS_TranslateType_SQLTo4D

Voici la méthode utilisée dans la transposition des types SQL vers les constantes 4D qui serontutilisées lors de la création des tables par Assimilator :

Au cas ou

: (($1="VARCHAR") | ($1="VARCHAR2") | ($1="NVARCHAR2") | ($1="SYSNAME"))$0:=Est un champ alpha

: (($1="CHAR") | ($1="NCHAR") | ($1="NVARCHAR") | ($1="ENUM"))$0:=Est un champ alpha

: (($1="INTEGER") | ($1="TINYINT") | ($1="SMALLINT") | ($1="MEDIUMINT"))$0:=Est un entier

: (($1="INT") | ($1="INT32") | ($1="LONG") | ($1="BIGINT"))$0:=Est un entier long

: (($1="NUMBER") | ($1="AUTONUMBER"))$0:=Est un entier long

: (($1="INT64") | ($1="NUMERIC"))$0:=Est un entier 64 bits

: (($1="DATE") | ($1="DATETIME"))$0:=Est une date

: (($1="TIME") | ($1="TIMEDATE") | ($1="DURATION") | ($1="INTERVAL"))$0:=Est une heure

: (($1="BOOL") | ($1="BOOLEAN") | ($1="BIT") | ($1="BIT VARYING"))$0:=Est un booléen

: (($1="REAL") | ($1="FLOAT") | ($1="DECIMAL") | ($1="NUMERIC"))$0:=Est un numérique

: (($1="DOUBLE") | ($1="SINGLE") | ($1="DOUBLE PRECISION"))$0:=Est un numérique

: (($1="MONEY") | ($1="CURRENCY"))$0:=Est un numérique

: (($1="TEXT")|($1="NTEXT")|($1="TINYTEXT")|($1="MEDIUMTEXT")|($1="LONGTEXT"))$0:=Est un texte

: (($1="BLOB") | ($1="CLOB") | ($1="BINARY") | ($1="VARBINARY"))$0:=Est un BLOB

: (($1="NCLOB") | ($1="TINYBLOB") | ($1="MEDIUMBLOB") | ($1="LONGBLOB"))$0:=Est un BLOB

: (($1="LONGVARBINARY") | ($1="BFILE") | ($1="LONGRAW") | ($1="RAW"))$0:=Est un BLOB

: (($1="IMAGE") | ($1="PICTURE"))$0:=Est une image

: ($1="SUBTABLE")$0:=Est une sous table

Sinon Mssg ("ALERT";"Type de données non reconnu ";$1)$0:=Est une variable indéfinie

Fin de cas

ASS_GetTableList_SQLSvr2000

Dans cette méthode on effectue une requête sur plusieurs tables système afin d'en extraire les tables“user” identifiées par le xtype “u”, ainsi que les colonnes correspondantes. On notera que cette versionde MS SQL Server n'utilise pas les vues INFORMATION_SCHEMA .

Comme pour MySQL, le tableau arraySrc_Size_aL doit être ajusté à la taille du tableauSrc_Type_aT. Le travail final consiste de créer un tableau de valeurs distinctes dansAss_TableList_aT qui sera affiché dans le dialogue d'Assimilator.


Si (vSQL_Ref_A19#"")Debut SQL

SELECT SysObjects.id, SysObjects.name, SysColumns.name, SysTypes.name, SysColumns.lengthFROM SysObjects, SysColumns, SysTypesWHERE SysObjects.id = SysColumns.idAND SysColumns.xtype = sysTypes.xtypeAND SysObjects.xtype = 'U'ORDER BY 2, 3INTO :Src_TableID_aL, :Src_Table_aT, :Src_Column_aT, :Src_Type_aT, :Src_Size_aL;

Fin SQL

`======================== Actions methode ===============================

`// On ajuste le tableau Src_Size_L sur le tableau Src_Type_aT $Idx:=0$SOA:=Taille tableau (Src_Type_aT)Boucle ($Ndx;1;$SOA)

$Idx:=$Idx+1Src_Type_aT{$Ndx}:=Majusc (Src_Type_aT{$Ndx})$Type_L:=ASS_TranslateType_SQLTo4D (Src_Type_aT{$Ndx})Au cas ou

: (($Type_L=Est un texte ) | ($Type_L=Est un champ alpha ))Sinon

INSERER DANS TABLEAU (Src_Size_aL;$Idx)Src_Size_aL{$Idx}:=ASS_4DSizeFromSQLType (Src_Type_aT{$Idx})


TABLEAU ENTIER LONG(Ass_TableID_aL;0)ARR_Distinct (->Src_TableID_aL;->Ass_TableID_aL)$SOA:=Taille tableau (Ass_TableID_aL)TABLEAU TEXTE(Ass_TableList_aT;$SOA)Boucle ($Ndx;1;$SOA)

$RIS:=Chercher dans tableau (Src_TableID_aL;Ass_TableID_aL{$Ndx})Ass_TableList_aT{$Ndx}:=Src_Table_aT{$RIS}

Fin de boucle

TABLEAU BOOLEEN (Ass_SelectedTable_aB;$SOA)TABLEAU ENTIER LONG(Ass_TableSize_aL;$SOA)TABLEAU ENTIER LONG(Ass_RowCount_aL;$SOA)

Boucle ($Ndx;1;$SOA)$Cnt_L:=Compter dans tableau (Src_Table_aT;Ass_TableList_aT{$Ndx})$Sdx:=Chercher dans tableau (Src_Table_aT;Ass_TableList_aT{$Ndx})$Idx:=1

13 / 36



Ass_TableSize_aL{$Ndx}:=$Size_LAss_RowCount_aL{$Ndx}:=ASS_GetRowCount (Ass_TableList_aT{$Ndx})

Fin de boucle

`======================== Nettoyage et sortie =============================

ASS_SQL_Logout

Fin de si

Les méthodes qui suivent sont toutes liées au dialogue Assimilator_d.

ASS_OpenAssimilator

La seule fonctionnalité de la méthodeASS_OpenAssimilator est l'ouverture du dialogueAssimilator_d. Toutes les opérations se font lors de l'événement formulaire sur chargement de laméthode formulaire ou des méthodes objets.

Assimilator_d. Ass_Tables_aB

Cette méthode objet répond à deux événements : Sur Clic et Sur Données Modifiées.Sur Clic réagit aux clics sur la liste des tables etSur DonnéesModifiées réagit aux clics sur le tableaude booléen Ass_SelectedTable_aB qui indique si la table doit être assimilée.

ASS_BuildListOfFields

Quand un utilisateur clique sur un rang de la liste des tablesla méthodeASS_BuildListOfFieldsvideles tableaux process utilisés pour définir une table puis les remplit pour redéfinir la table choisie.

C_TEXTE($TableName_T;$1)

$TableName_T:=$1

$SOA:=Taille tableau (Ass_FieldName_aT)Si ($SOA>0)

EFFACER VARIABLE (Ass_FieldName_aT)EFFACER VARIABLE (Ass_FieldType_aT)EFFACER VARIABLE (Ass_FieldLength_aL)EFFACER VARIABLE (Ass_SelectedField_aB)

Fin de si

`======================== Actions methode ==================================

`// Compter le nombre de colonnes associees a $TableName_T `//$SOA:=Compter dans tableau (Src_Table_aT;$TableName_T)TABLEAU TEXTE(Ass_FieldName_aT;$SOA)TABLEAU TEXTE(Ass_FieldType_aT;$SOA)TABLEAU ENTIER LONG(Ass_FieldLength_aL;$SOA)

TABLEAU BOOLEEN (Ass_SelectedField_aB;$SOA)

$Sdx:=Chercher dans tableau (Src_Table_aT;$TableName_T)$Idx:=1

Boucle ($Ndx;$Sdx;($SOA+$Sdx)-1)Ass_FieldName_aT{$Idx}:=Src_Column_aT{$Ndx}Ass_FieldType_aT{$Idx}:=Src_Type_aT{$Ndx}Ass_FieldLength_aL{$Idx}:=Src_Size_aL{$Ndx}Ass_SelectedField_aB{$Idx}:=((Ass_FieldType_aT{$Idx}#"SUBTABLE")

& (Ass_FieldType_aT{$Idx}#"UNDEFINED"))$Idx:=$Idx+1

Fin de boucle

CB_CheckAll_Fields:=Num ($SOA>0)

ASS_GetRecordCount

La base de données cible retourne le nombre d'enregistrements dans la table choisie.

Note : Toutes les tables à assimiler doivent être cliquées afin de connaître la table qui a le plus grandnombre d'enregistrements. Avant d'assimiler cette table doit être surlignée et le curseur vThrottle_Lajusté. Sur la base de ce nombre le curseur vThrottle_L sera ajusté afin d'indiquer au programme laquantité d'enregistrements à importer à chaque cycle.

Soyez vigilant sur le nombre d'enregistrements importés sous peine de rencontrer des problèmes demémoire. Les enregistrements de 4D sont créés via la commande TABLEAU VERS SELECTION etpar conséquent tout transite par des tableaux. Définir ce qu'est un grand nombre d'enregistrements ?Cela dépend du data à importer.

La valeur " enregistrements par cycle " doit être calculée par rapport à la charge en mémoire et pasforcément par rapport au nombre d'enregistrements : une table avec des enregistrements contenantde nombreux BLOB sera plus gourmande en mémoire qu'une autrene contenant que desenregistrements fait d'entiers longs.

C_TEXTE($SQL_T)

C_REEL($Bytes_R)

`======================== Actions methode ==================================

vSQL_Ref_A19:=ASS_SQL_Login Si (vSQL_Ref_A19#"")

$SQL_T:="SELECT COUNT(*) FROM "+Ass_TableList_aT{Ass_TableList_aT}+";"SQL EXECUTER($SQL_T;vRecordCnt_L)SQL CHARGER ENREGISTREMENTSQL ANNULER CHARGEMENT

ASS_SQL_Logout

Sinon vRecordCnt_L:=0

15 / 36

Fin de si


vRPC_L:=ASS_CalcRecordsPerCycle (vRecordCnt_L;vThrottle_L)$Bytes_R:=vRPC_L*Ass_TableSize_aL{Ass_TableList_aT}vBPC_T:=ASS_BytesToUnitOfMeasure ($Bytes_R)

ASS_CalcRecordsPerCycle

Quandle curseurestdéplacé,le nombred'enregistrementsà importerestrecalculé.La valeurdoit êtreconsidéréepour la table la plus avide en mémoire et pas forcément celle contenant le plusd'enregistrements.

C_ENTIER LONG($0)C_ENTIER LONG($Count_L;$1)C_ENTIER LONG($Throttle_L;$2)

`====================== Initialisation ================================

$Count_L:=$1$Throttle_L:=$2

`======================== Actions methode ==================================

Si ($Count_L>0)$0:=Arrondi ($Count_L*($Throttle_L/100);0)

Sinon $0:=0

Fin de si

ASS_BytesToUnitOfMeasure

La méthodeASS_BytesToUnitOfMeasureretourne la valeur qui sera affichée en page 1 du dialogueAssimilator. Cette valeur est une estimation en octet des données à importer lors de chaque cycle.

Cette estimation doit être située dans le contexte. En effetla taille des champs BLOB, texte, image etautres champs à taille indéfinie n'est pas retournée dans cecalcul. Tous les autres champs ont une taillefixe définie, c'est celle-ci qui sera prise en compte dans le calcul.

C_TEXTE($0;$Result_T)

C_REEL($Size_R;$1) `====================== Initialisation ================================

$Size_R:=$1

`======================== Actions methode ==================================

Au cas ou : ($Size_R>=(2^50))

$Result_T:=Chaine (Arrondi ($Size_R/(2^50);2))+" PB" `// petabyte: ($Size_R>=(2^40))

$Result_T:=Chaine (Arrondi ($Size_R/(2^40);2))+" TB" `// terabyte: ($Size_R>=(2^30))

$Result_T:=Chaine (Arrondi ($Size_R/(2^30);2))+" GB" `// gigabyte: ($Size_R>=(2^20))

$Result_T:=Chaine (Arrondi ($Size_R/(2^20);2))+" MB" `// megabyte: ($Size_R>=(2^10))

$Result_T:=Chaine (Arrondi ($Size_R/(2^10);2))+" Kb" `// kilobyteSinon

$Result_T:=Chaine ($Size_R;"#,##0")+" bytes"Fin de cas


$0:=$Result_T

ASS_OM_Assimilator_d_aTab

Cette méthode, appelée par la méthode objetAssimilator_d.aTab, permet de charger ou de vider lalistbox de la page 2 du dialogue Assimilator.

Lorsqu'une table a été sélectionnée en page 1 et que vous cliquez sur l'onglet " prévisualisation ", laméthode appelleASS_GetRecords_Previewqui essaie de charger au plus 25 enregistrements de la basede données ciblée.

Les champs au contenu binaire comme les champs BLOB, image, etc. ne sont pas chargés pourl'affichage.

Si (aTab=2)

`======================== Actions methode ==============================

Si (Ass_TableList_aT<1)aTab:=1ALLER A PAGE(aTab)Mssg ("ALERT";" information Incomplète";"Vous devez choisir une Table !")

Sinon C_POINTEUR(vTemp1_P;vTemp2_P)C_TEXTE($Varname_T;$HeaderVar_T)

ASS_PairArraysToColumns

`// Les tableaux doivent charges avant d'etre associes aux listbox `// afin d'eviter les problemes de chergement et de taille `//ASS_GetRecords_Preview

`// On associe maintenant aux listbox `//Boucle ($Ndx;1;Taille tableau (Ass_FieldName_aT))

Si (Non (Nil (TempArray_aP{$Ndx})))$HeaderVar_T:="vHdr_"+Chaine ($Ndx)+"_L"EXECUTER FORMULE(Nom commande (283)+"("+$HeaderVar_T+";0)")vTemp2_P:=Pointeur vers ($HeaderVar_T)

17 / 36

vTemp1_P:=TempArray_aP{$Ndx}INSERER COLONNE LISTBOX (*;"Records_aB";$Ndx;$Varname_T;

vTemp1_P->;$HeaderVar_T;vTemp2_P->)TITRE BOUTON(*;$HeaderVar_T;Ass_FieldName_aT{$Ndx})CHANGER TAILLE (*;$HeaderVar_T;11)CHANGER STYLE(*;$HeaderVar_T;Gras )


CHOIX VISIBLE BARRES DEFILEMENT(*;"Records_aB";Vrai ;Vrai )Fin de si

Sinon Boucle ($Ndx;Taille tableau (TempArray_aP);1;-1)

Si (Non (Nil (TempArray_aP{$Ndx})))SUPPRIMER COLONNE LISTBOX (*;"Records_aB";$Ndx;1)EFFACER VARIABLE (TempArray_aP{$Ndx}->)


ASS_PrefsViewed_B:=Choisir (ASS_PrefsViewed_B;ASS_PrefsViewed_B;aTab=3)

Fin de si


◊assimprogress:="" `


La méthodeASS_PairArraysToColumnsgère le tableauTempField_aP. Elle vérifie la taille dutableau ; si cette taille est supérieure à 0 la méthode fait un EFFACER VARIABLE pour ramener à 0tous les éléments des tableaux pointés.

Ensuite elle boucle sur le tableauAss_FieldName_aTet crée les tableaux nécessaires à la constructiondes listbox destinés à l'affichage de chacune des colonnes de la table à assimiler :

`// Menage : on efface le contenu de tous les tableaux process "Col_"

`//$SOA:=Taille tableau (TempArray_aP)Si ($SOA>0)

Boucle ($Ndx;1;$SOA)Si (Non (Nil (TempArray_aP{$Ndx})))

EFFACER VARIABLE (TempArray_aP{$Ndx}->)Fin de si

Fin de boucle EFFACER VARIABLE (Ass_ArrayNames_aT)

Fin de si

`======================== Actions methode ==================================

$SOA:=Taille tableau (Ass_FieldName_aT)

`// On cree les tableaux necessaires aux listbox `//TABLEAU TEXTE(Ass_ArrayNames_aT;$SOA)TABLEAU POINTEUR(TempArray_aP;0)Boucle ($Ndx;1;$SOA)

Si (Ass_FieldType_aT{$Ndx}#"SUBTABLE")vTemp1_P:=ASS_CreateArray ($Ndx)AJOUTER A TABLEAU (TempArray_aP;vTemp1_P)

Sinon Ass_ArrayNames_aT{$Ndx}:=""AJOUTER A TABLEAU (TempArray_aP;vNil_P)

Fin de si

Fin de boucle

ASS_CreateArray

La méthodeASS_CreateArrayreçoit les index dans le tableauAss_FieldType_aTet traduit les typesSQL en constantes 4D via la méthode ASS_TranslateType_SQLTo4D décrite plus haut.

D'après la constante obtenue la méthode fait unEXECUTER FORMULE pour créer un tableaucompatible avec le type ou redimensionner à zéro le tableau existant. La méthode créée un tableauimage pour transférer les BLOBs ; le BLOB est intégré automatiquement dans le tableau image enutilisant la technique décrite dans la note technique réf. 4D-200903-06-FR "4D v11 SQL : Pass-Through sans ODBC".

En sens inverse, on utilise le codec ".4DBLOB" lors de l'appel à la méthodeIMAGE VERS BLOBpour l'extraction.

C_POINTEUR($0)

C_ENTIER LONG($1;$Type_L)

`====================== Initialisation ================================

$Ndx:=$1$Type_L:=ASS_TranslateType_SQLTo4D (Ass_FieldType_aT{$Ndx})

`======================== Actions methode ==================================

Au cas ou : ($Type_L=Est un entier )

$Varname_T:="Col_"+Chaine ($1)+"_aI"EXECUTER FORMULE(Nom commande (220)+"("+$Varname_T+";0)")

: ($Type_L=Est un entier long )$Varname_T:="Col_"+Chaine ($1)+"_aL"EXECUTER FORMULE(Nom commande (221)+"("+$Varname_T+";0)")

: ($Type_L=Est un numérique )$Varname_T:="Col_"+Chaine ($1)+"_aR"EXECUTER FORMULE(Nom commande (219)+"("+$Varname_T+";0)")

: ($Type_L=Est un texte )$Varname_T:="Col_"+Chaine ($1)+"_aT"EXECUTER FORMULE(Nom commande (222)+"("+$Varname_T+";0)")

19 / 36

: ($Type_L=Est un champ alpha )$Varname_T:="Col_"+Chaine ($1)+"_aA"EXECUTER FORMULE(Nom commande (222)+"("+$Varname_T+";0)")

: ($Type_L=Est un booléen )$Varname_T:="Col_"+Chaine ($1)+"_aB"EXECUTER FORMULE(Nom commande (223)+"("+$Varname_T+";0)")

: ($Type_L=Est un BLOB )$Varname_T:="Col_"+Chaine ($1)+"_aX"EXECUTER FORMULE(Nom commande (279)+"("+$Varname_T+";0)")

: ($Type_L=Est une date )$Varname_T:="Col_"+Chaine ($1)+"_aD"EXECUTER FORMULE(Nom commande (224)+"("+$Varname_T+";0)")

: ($Type_L=Est une heure )$Varname_T:="Col_"+Chaine ($1)+"_aH"EXECUTER FORMULE(Nom commande (221)+"("+$Varname_T+";0)")

: ($Type_L=Est une image )$Varname_T:="Col_"+Chaine ($1)+"_aG"EXECUTER FORMULE(Nom commande (279)+"("+$Varname_T+";0)")

Fin de cas

`======================== Nettoyage et sortie ============================Ass_ArrayNames_aT{$Ndx}:=$Varname_T

$0:=Pointeur vers ($Varname_T)

ASS_GetRecords_Preview

ASS_GetRecords_Previewexécute une boucle qui construit chacun des tableaux affichés sur la page 2du dialogue. Les données binaires ne sont pas affichées.


Si (vSQL_Ref_A19#"")$SOA:=Taille tableau (Ass_FieldName_aT)

`======================== Actions methode =============================

$Size_L:=0Boucle ($Ndx;1;$SOA)

Au cas ou `// On ne fait rien pour les types de données suivants `//

: (Ass_FieldType_aT{$Ndx}="BLOB"): (Ass_FieldType_aT{$Ndx}="PICTURE"): (Ass_FieldType_aT{$Ndx}="SUBTABLE"): (Ass_FieldType_aT{$Ndx}="POINTER"): (Ass_FieldType_aT{$Ndx}="UNDEFINED")Sinon

$SQL_T:="SELECT "+Ass_FieldName_aT{$Ndx}+" FROM "+Ass_TableList_aT{Ass_TableList_aT}

SQL EXECUTER($SQL_T;TempArray_aP{$Ndx}->)

SQL CHARGER ENREGISTREMENT(25)

Si ($Size_L<Taille tableau (TempArray_aP{$Ndx}->))$Size_L:=Taille tableau (TempArray_aP{$Ndx}->)

Fin de si

`// si nousn'avons pas atteint la fin de la requête SELECT, `// inutile de réinitialiser le curseur `//Si (Non (SQL Fin de selection ))

SQL ANNULER CHARGEMENTFin de si


`======================== Nettoyage et sortie ==========================

ASS_SQL_Logout

`// Comme il y a des tables qui ne seront pas affichées dans l'échantillon, `// ces tableaux doivent etre redimensionés `//Boucle ($Ndx;1;$SOA)

Si (Non (Nil (TempArray_aP{$Ndx})))Si (Taille tableau (TempArray_aP{$Ndx}->)<$Size_L)

$Count_L:=$Size_L-Taille tableau (TempArray_aP{$Ndx}->)$At_L:=Taille tableau (TempArray_aP{$Ndx}->)+1INSERER DANS TABLEAU (TempArray_aP{$Ndx}->;$At_L;$Count_L)

Fin de si Fin de si

Fin de boucle

Fin de si

ASS_OM_Assimilator_d_Btn_Assim

ASS_OM_Assimilator_d_Btn_Assim est appelée par la méthode objetAssimilator_d.Btn_Assimilate. La fonction de cette méthode est de vérifier les choix sur les pages "Tables" et"Préférences import" du dialogue.

La méthode tente en premier lieu de créer les tables qui ont été choisies pour l'import. Si la case"importer les enregistrements" est cochée alors les enregistrements seront également "assimilés"

C_TEXTE($Message_T;$1)

OK:=1Si (Non (ASS_PrefsViewed_B))

Mssg ("CONFIRM";"Anomalie process";"Les préferences page 3 n'ont pas été mises à jour,voulez vous continuer?";"Oui";"Non")

Fin de si

Si (OK=1)$Message_T:=$1

$TBCount_L:=Lire numero derniere TableTABLEAU TEXTE(TBName_aT;0)Boucle ($Ndx;1;$TBCount_L)

21 / 36

`// crée un tableau des noms de tables courantes `//Si (Est un numero de Table valide ($Ndx))

AJOUTER A TABLEAU (TBName_aT;Nom de la table ($Ndx))Fin de si

Fin de boucle

Au cas ou : ($Message_T="Tables")

Si (Compter dans tableau (Ass_SelectedTable_aB;Vrai )=0)Mssg ("ALERT";"Information incomplète ";"Aucune table choisie pour l'assimilation.")

Sinon $UseExistingTable_B:=RB_UseExistingTable=1$CreateTable_B:=RB_CreateNewTable=1$ReplaceTable_B:=RB_ReplaceTable=1

$SOA:=Taille tableau (Ass_SelectedTable_aB)

$TBCount_L:=0 `// Assimiler la structure `//Boucle ($Ndx;1;$SOA)

OK:=1Si (Ass_SelectedTable_aB{$Ndx})

$TableExists_B:=Chercher dans tableau (TBName_aT; Ass_TableList_aT{$Ndx})>0Si ($TableExists_B)

Au cas ou : ($ReplaceTable_B)

Si ($TableExists_B)◊assimprogress:="Deleting records from tables"

$SQL_T:="DROP Table IF EXISTS "+Ass_TableList_aT{$Ndx} +";"Debut SQL

EXECUTE IMMEDIATE :$SQL_TFin SQL

ENDORMIR PROCESS(Numero du process courant ;60)◊assimprogress:=""

Fin de si

: ($CreateTable_B)Mssg ("MESSAGE Open";"Creating tables")Si ($TableExists_B)

Repeter $NewTableName_T:=Demander ("Une Table nommée "+Ass_TableList_aT{$Ndx}

+" existe déjà, saisissez un autre nom")Jusque ((($NewTableName_T#Ass_TableList_aT{$Ndx})

& ($NewTableName_T#"")) | (OK=0))Si (OK=1)

Ass_TableNames_aT{$Ndx}:=$NewTableName_TFin de si

Fin de si Mssg ("MESSAGE Close")

Sinon `// $UseExistingTable_B est vrai

Fin de cas

Si (OK=1)Si (Non (ASS_CreateTable (Ass_TableList_aT{$Ndx} ;Ass_TableNames_aT{$Ndx})))

`// Problème au niveau de la création de table `//Mssg ("ALERT";"Anomalie Process";"Assimilation stoppée Pendant la création

de la Table : "+Ass_TableList_aT{$Ndx}+".")OK:=0$Ndx:=$SOAASS_TablesCreated_B:=Faux

Sinon ASS_TablesCreated_B:=Vrai$TBCount_L:=$TBCount_L+1

Fin de si

Sinon `// Renomage annulé par l'utilisateur `//Mssg ("ALERT";"Anomalie Process";"Assimilation stoppée Pendant le renommage

de la Table : "+Ass_TableList_aT{$Ndx}+".")OK:=0$Ndx:=$SOAASS_TablesCreated_B:=Faux

Fin de si

Sinon ASS_CreateTable (Ass_TableList_aT{$Ndx} ; Ass_TableNames_aT{$Ndx})ASS_TablesCreated_B:=Vrai$TBCount_L:=$TBCount_L+1

Fin de si Fin de si

Fin de boucle

Mssg ("ALERT";"Résultats de l'assimilation des tables";Chaine ($TBCount_L)+" "+Choisir ($TBCount_L=1;"Table";"tables")+" assimilée(s).")

Fin de si

: ($Message_T="Data")Si (OK=1)

Si (Compter dans tableau (Ass_SelectedTable_aB;Vrai )=0)Mssg ("ALERT";"Erreur d'assimilation des données";"Aucune table choisie pour l'assimilation.")

Sinon Si (Non (ASS_TablesCreated_B))

Mssg ("CONFIRM";"Anomalie process";"Les tables n'ont pas été créées durant leprocess, voulez-vous recommencer?";"Oui";"Non")

Si (OK=1)COPIER TABLEAU (Ass_TableList_aT;Ass_TableNames_aT)Mssg ("CONFIRM";"Anomalie process";"Y a-t-il des changements de nom des

tables à assimiler?";"Oui";"Non")Si (OK=1)

Ass_TableList_aT:=1$Winref_L:=Creer fenetre formulaire ("ASS_NameChooser_d";

Form fenêtre standard ;Centrée horizontalement ;Centrée verticalement )DIALOGUE ("ASS_NameChooser_d")FERMER FENETRE($Winref_L)

Fin de si OK:=1

Fin de si Fin de si

23 / 36

Si (OK=1) `// Assimilate the records `//$TBCount_L:=0$ReplaceData_B:=(RB_ReplaceData=1)$SOA:=Taille tableau (Ass_SelectedTable_aB)Boucle ($Ndx;1;$SOA)

Si (Ass_SelectedTable_aB{$Ndx})$TBCount_L:=$TBCount_L+1Si ($ReplaceData_B)

$RIS:=Lire numero derniere TableBoucle ($Ndx;1;$RIS)

Si (Est un numero de Table valide ($Ndx))$Name_T:=Nom de la table ($Ndx)$Table_P:=Table ($Ndx)$Ndx:=$RIS


TOUT SELECTIONNER($Table_P->)SUPPRIMER SELECTION($Table_P->)

Fin de si

OK:=1vSQL_Ref_A19:=ASS_SQL_Login Si (vSQL_Ref_A19#"")

ASS_GetRecords_Import (Ass_TableList_aT{$Ndx}; Ass_TableNames_aT{$Ndx})ASS_SQL_Logout

Fin de si Fin de si

Fin de boucle

Mssg ("ALERT";"Résultats de l'assimilation des données";Chaine ($TBCount_L)+" "+Choisir ($TBCount_L=1;"Table";"tables")+" assimilée(s).")

Fin de si Fin de si

Fin de si Fin de cas

Fin de si

ASS_CreateTable

ASS_CreateTablegère la création des champs et accepte 2 arguments :$Old_TableName_T quireçoit le nom de la table tel qu'il est défini dans la base externe à assimiler, et $New_TableName_Tqui est le nom de la table à créer dans la base 4D. Si le nom utilisé dans la base externe existe déjà dansla base 4, la méthode utilise alors la valeur de $New_TableName_T pour créer la nouvelle table.Le code$New_TableName_T : = "["+$New_TableName_T + "]" vérifie que le nom de la table est compatibleavec le langage SQL.

Chaque vendeur de bases externes ajoutant ses propres valeurs au standard SQL 92, cela fait autant detypes de colonnes à prendre en charge. Assimilator reconnaît la plupart des types mais pas la totalité ;le type SET utilisé par MySQL n'est pas reconnu par exemple.

Le tableauAss_FieldName_aTest traité et ses données sont traduites dans un type compréhensible par4D. Ce format 4D est ensuite converti dans un type 4D SQL tel qu'on les retrouve dans ladocumentation 4D Référence SQL disponible à l'adresse suivante :

http://www.4d.com/docs/QLC/QLCMDFR.HTM

NOTE : Un effort particulier a été apporté pour prendre en chargela plupart des types SQL diffusés sur lemarché, cependant les types varient d'un éditeur à l'autre, et d'une version de produit à une autre.

De plus certains types ne peuvent être pris en charge qu'au cas par cas selon la façon dont ils sontimplémentés dans la table de la base de données.

Ce composant facilite les tests et les ajustements au gré des différences rencontrées, il est très facilede modifier le code du composant afin de l'ajuster selon les besoins de la base à assimiler. Il relèvede la responsabilité du développeur de veiller à tous ces ajustements avant de finaliserl'assimilation.

C_BOOLEEN ($0;$Continue_B)

C_TEXTE($Old_TableName_T;$1)C_TEXTE($New_TableName_T;$2) `----------------------------------------------------------------------------C_ENTIER LONG($Ndx;$SOA;$RIS;$Type_L;$Selected_L;$Added_L)C_TEXTE($TableName_T;$SQL_T;$Columns_T)

`====================== Initialisation ================================

`// L'utilisateur peut avoir changé le nom des tables `//$Old_TableName_T:=$1$New_TableName_T:=$2$Continue_B:=Vrai

Si (Compter dans tableau (Ass_SelectedTable_aB;Vrai )>1)ASS_BuildListOfFields ($Old_TableName_T)

Fin de si

$SOA:=Taille tableau (Ass_FieldName_aT)

`======================== Actions methode =============================

Si (Position (" ";$New_TableName_T)>0)$New_TableName_T:="["+$New_TableName_T+"]"

Fin de si

$Selected_L:=Compter dans tableau (Ass_SelectedField_aB;Vrai )$Added_L:=0

$Columns_T:=" ("

Boucle ($Ndx;1;$SOA)Si (Ass_SelectedField_aB{$Ndx})

$Added_L:=$Added_L+1Si (Position (" ";Ass_FieldName_aT{$Ndx})>0)

$Columns_T:=$Columns_T+"["+Ass_FieldName_aT{$Ndx}+"] "Sinon

25 / 36

$Columns_T:=$Columns_T+Ass_FieldName_aT{$Ndx}+" "Fin de si

$Type_L:=ASS_TranslateType_SQLTo4D (Ass_FieldType_aT{$Ndx})

Au cas ou

: ($Type_L=Est un champ alpha )Si (Ass_FieldLength_aL{$Ndx}<256)

$Columns_T:=$Columns_T+"VARCHAR"+"("+Chaine (Ass_FieldLength_aL{$Ndx})+")"+Choisir ($Added_L<$Selected_L;", ";");")

Sinon $Columns_T:=$Columns_T+"TEXT"+Choisir($Added_L<$Selected_L;", ";");")

Fin de si

: ($Type_L=Est un entier )$Columns_T:=$Columns_T+"SMALLINT"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est un entier long )$Columns_T:=$Columns_T+"INT"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est une date )$Columns_T:=$Columns_T+"TIMESTAMP"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est une heure )$Columns_T:=$Columns_T+"DURATION"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est un booléen )$Columns_T:=$Columns_T+"BOOLEAN"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est un numérique )$Columns_T:=$Columns_T+"REAL"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est un texte )$Columns_T:=$Columns_T+"TEXT"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est un BLOB )$Columns_T:=$Columns_T+"BLOB"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est une image )$Columns_T:=$Columns_T+"PICTURE"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est un entier 64 bits )$Columns_T:=$Columns_T+"NUMERIC"+Choisir($Added_L<$Selected_L;", ";");")

: ($Type_L=Est une sous table )

Sinon $Continue_B:=Faux

Fin de cas Fin de si

Fin de boucle

Si ($Continue_B)$SQL_T:="CREATE TABLE IF NOT EXISTS "+$New_TableName_T+$Columns_T

Debut SQLEXECUTE IMMEDIATE :$SQL_T

Fin SQL

Fin de si

`======================== Nettoyage et sortie ===========================

$0:=$Continue_B

ASS_GetRecords_Import

La méthodeASS_GetRecords_Importboucle sur les tables sélectionnées pour assimiler les données.ASS_GetRecords_Importboucle dans un répeter/jusque en fonction de la valeur de la variable processvRPC_L. La seule exception est dans l'assimilation d'une base MS SQL Server 2000

MS SQL Server 2000 ne prend pas en charge les clausesLIMIT et OFFSET qui permettent de définirle début de la sélection et le nombre de lignes sélectionnées. Si vous cherchez dans votre moteur derecherche favori la phrase " clauseLIMIT dans SQL Server 2000 " vous découvrirez plusieurstechniques permettant d'émuler la clause LIMIT des versions actuelles de MySQL et PostgreSQL.

En ce qui concerne MS SQL Server 2000, cette Note technique implémente une technique simple : ellefait une requêteSQL ALL RECORDS . Pour émulerLIMIT et OFFSET vous devrez intégrer dansASS_GetRecords_Importdu code semblable à l'exemple ci-dessous. Vous aurez besoind'une cléprimaire sachant que le contournement est basé sur un tri etque cette note technique n'assimile qu'unecolonne à la fois.

$SQL_T : = "SELECT "+ $KeyCol_L + " "+ Ass_FieldName_aT{$Ndx}

$SQL_T : = $SQL_T + " FROM (SELECT TOP"+ String ($RPC_L) + $KeyCol_L + ","+ Ass_FieldName_aT{$Ndx}$SQL_T : = $SQL_T + " FROM (SELECT TOP"+ String ($RPC_L + $Imported_L) + $KeyCol_L + ","+ Ass_FieldName_aT{$Ndx}$SQL_T : = $SQL_T + " FROM "+ $Ext_TableName_T$SQL_T : = $SQL_T + " ORDER BY "+ KeyCol_L + " ASC)"$SQL_T : = $SQL_T + " ORDER BY "+ KeyCol_L + " DESC)"$SQL_T : = $SQL_T + " ORDER BY "+ KeyCol_L + " ASC ;"

4D v11 SQL prend en charge LIMIT et OFFSET tel que documenté ici : ftp://ftp-public.4d.fr/Documents/Products_Documentation/LastVersions/Line_11/Vf/PDF_Format/4D_v11_Reference_SQL_r4.pdf

voir commande SELECT, page 90 - La documentation en ligne esten cours d'élaboration au momentde la publication de cette note -.

Pour les besoins de cette note seulOFFSET est requis dans la mesure où le paramètre "ObjetLié" deSQL EXECUTER implémente déjà la clause LIMIT .

Pour récupérer plusieurs colonnes par programmation, Assimilator utiliseSQL EXECUTER dans uneboucle Tant que (). Cette boucle parcourt les colonnes et transfert les données colonne par colonne.

27 / 36

La sélection courante de la table à importer étant réduite à zéro en début de boucle (REDUIRESELECTION ($Table_P- > ; 0)) le premier appel àTABLEAU VERS SELECTION créera lasélection et chacun des appels suivants renseignera le champ adéquat au sein de cette sélection. Ne sachant pas à l'avance combien de colonnes sont contenuesdans une table, nous avons étudié lapossibilité d'appelerTABLEAU VERS SELECTION au sein d'une commandeEXECUTERFORMULE , en bouclant sur les tableaux afin de construire la formule.Cette technique a été écartéeafin d'éviter tout problème de longueur de chaîne de caractères ; la solution retenue consistant à bouclersur les colonnes, une par une.

C_TEXTE($Ext_TableName_T;$1)

C_TEXTE($4D_TableName_T;$2) C_ENTIER LONG($Ndx;$Fdx;$Idx;$SOA;$RIS;$Table_L;$Size_L)C_ENTIER LONG($Count_L;$Imported_L;$RPC_L;$Type_L;$Offset)C_POINTEUR($Table_P;$Field_P)C_TEXTE($Table_T;$SQL_T)C_TEXTE($Name_T)C_ENTIER LONG($TableNum;$FieldNum)C_BOOLEEN ($ContainsNoBLOBs_B)

`====================== Initialisation ================================

`// L'utilisateur peut avoir changé le nom des tables `//$Ext_TableName_T:=$1$4D_TableName_T:=$2

ASS_BuildListOfFields ($Ext_TableName_T)


$SOA:=Taille tableau (Ass_FieldName_aT)$SQL_T:="SELECT COUNT(*) FROM "+$Ext_TableName_T+";"SQL EXECUTER($SQL_T;$Count_L)SQL CHARGER ENREGISTREMENTSQL ANNULER CHARGEMENT

$ContainsNoBLOBs_B:=(Chercher dans tableau (Ass_FieldType_aT;"BLOB")<1)

`======================== Actions methode ==================================

`// récuperer pointeur et numéro de table `//$RIS:=Lire numero derniere TableBoucle ($Ndx;1;$RIS)

Si (Est un numero de Table valide ($Ndx))$Name_T:=Nom de la table ($Ndx)Si ($Name_T=$4D_TableName_T)

$Table_L:=$Ndx$Table_P:=Table ($Table_L)$Ndx:=$RIS

Fin de si Fin de si

Fin de boucle

`// récuperer tableau depointeurs vers champs `//$RIS:=Lire numero dernier Champ ($Table_L)TABLEAU POINTEUR(Fields_aP;$SOA)


Boucle ($Fdx;1;$RIS)Fields_aP{$Ndx}:=ASS_GetFieldPointer ($Table_L;Ass_FieldName_aT{$Ndx})

Fin de boucle Fin de si

Fin de boucle

$Imported_L:=0$Offset:=1$RPC_L:=vRPC_LMssg ("Progress Open";"Assimilation données";Chaine ($Count_L))Repeter

REDUIRE SELECTION($Table_P->;0)Mssg ("Progress Update";Chaine ($Imported_L);Chaine ($Imported_L;"###,###,###,##0

enregistrements assimilés.")

Si (($Imported_L+$RPC_L)>$Count_L)$RPC_L:=($Count_L-$Imported_L) `-1

Fin de si

`// importer les enregistrements dans des tableaux `//Boucle ($Ndx;1;$SOA)

$SQL_T:=""Au cas ou

: ((vDBVendor_T="4D v11 SQL Server") | (vDBVendor_T="4D v11 SQL Standalone"))Si (Ass_FieldType_aT{$Ndx}#"SUBTABLE")

$SQL_T:="SELECT "+Ass_FieldName_aT{$Ndx}+" FROM "+$Ext_TableName_T+" OFFSET "+Chaine ($Imported_L)+";"

Fin de si

: (vDBVendor_T="MySQL")$SQL_T:="SELECT "+Ass_FieldName_aT{$Ndx}+" FROM "+$Ext_TableName_T

+" LIMIT "+Chaine ($Imported_L)+","+Chaine ($RPC_L)+";"

: (vDBVendor_T="MS SQL Server 2000") `$SQL_T:="SELECT "+$KeyCol_L+" "+Ass_FieldName_aT{$Ndx} `$SQL_T:=$SQL_T+" FROM (SELECT TOP "+String($RPC_L)

+$KeyCol_L+"," +Ass_FieldName_aT{$Ndx} `$SQL_T:=$SQL_T+" FROM (SELECT TOP "+String($RPC_L+$Imported_L)

+ $KeyCol_L +"," +Ass_FieldName_aT{$Ndx} `$SQL_T:=$SQL_T+" FROM "+$Ext_TableName_T `$SQL_T:=$SQL_T+" ORDER BY "+KeyCol_L+" ASC)" `$SQL_T:=$SQL_T+" ORDER BY "+KeyCol_L+" DESC)" `$SQL_T:=$SQL_T+" ORDER BY "+KeyCol_L+" ASC;"

$SQL_T:="SELECT "+Ass_FieldName_aT{$Ndx}+" FROM "+$Ext_TableName_T+";"$RPC_L:=SQL Tous les enregistrements

Sinon Mssg ("ALERT";"Le support pour "+vDBVendor_T+" doit être implémenté";$MethodName_T+".")

Fin de cas Si ($SQL_T#"")

SQL EXECUTER($SQL_T;TempArray_aP{$Ndx}->)SQL CHARGER ENREGISTREMENT($RPC_L)

Si ($Size_L=0)$Size_L:=Taille tableau (TempArray_aP{$Ndx}->)

Fin de si

29 / 36

SQL ANNULER CHARGEMENTFin de si

Fin de boucle

$Offset:=$Offset+$RPC_L

`// Ajuster la taille des tableaux `//Boucle ($Ndx;1;$SOA)

Si (Non (Nil (TempArray_aP{$Ndx})))Si (Taille tableau (TempArray_aP{$Ndx}->)=0)

INSERER DANS TABLEAU (TempArray_aP{$Ndx}->;1;$Size_L)Fin de si


`// importer les données à partir des tableaux `//Mssg ("Progress Update";Chaine ($Imported_L);"Création de "+Chaine ($RPC_L;

"###,###,###,##0")+" enregistrements.")Si ($ContainsNoBLOBs_B)

ASS_ArrayToSelection

Sinon Boucle ($Ndx;1;$SOA)

Si (Non (Nil (TempArray_aP{$Ndx})))Si ((Type (TempArray_aP{$Ndx}->)=Est un tableau image )

& (Ass_FieldType_aT{$Ndx}="BLOB"))Boucle ($Idx;1;Taille tableau (TempArray_aP{$Ndx}->))

ALLER DANS SELECTION($Table_P->;$idx)IMAGE VERS BLOB (TempArray_aP{$Ndx}->{$Idx};Fields_aP{$Ndx}->;".4DBlob")STOCKER ENREGISTREMENT($Table_P->)

Fin de boucle Sinon

TABLEAU VERS SELECTION(TempArray_aP{$Ndx}->;Fields_aP{$Ndx}->)Fin de si


Fin de si


EFFACER VARIABLE (TempArray_aP{$Ndx}->)Fin de si

Fin de boucle

$Imported_L:=$Imported_L+Enregistrements trouves ($Table_P->)Jusque (($Imported_L>=$Count_L) | (vSQL_Ref_A19=""))


EFFACER VARIABLE (Fields_aP)

Mssg ("Progress Close")

Si (vSQL_Ref_A19="")Mssg ("ALERT";"Data Assimilation";"Connexion perdue.")

Fin de si

Utiliser 4D v11 SQL Assimilator

Le dialogue de connexion

La méthodeASS_OpenConnectionpermet d'afficher un dialogue composé de plusieurs pages. Si vous avezdéjà utilisé Assimilator dans ses versions antérieures, vous ne manquerez pas de remarquer que des ajoutsont été faits.

Vous devrez tout d'abord choisir l'éditeur de la base de données sur laquelle se connecter. Cela estobligatoire car chacun de ces éditeurs implémente son propre système de tables. La sélection faite dirigeravers une méthode spécialisée qui assimile la table de l'éditeur en question. Quand on assimile un data 4D v11SQL Server il n'y a pas de DSN car nous n'avons pas besoin de passer par ODBC.

Le menu est chargé depuis la liste 4D "ASS_DBTypes".Remarquez que tous les choix ne sont pas activéscar ils ne sont pas encore implémentés dans cette Note technique. Si vous décidez d'ajouter un deséditeurs désactivés, modifiez simplement son item en retirant le meta-caractère parenthèse ”( ”.Si vous désirez ajouter un produit non présent dans cette liste, il suffit de vous baser sur les exemples déjàprésents dans cette note technique et de vous inspirer des méthodes présentées plus haut.

De plus, en examinant la méthode objetConnect_d. Vendors_Menuvous comprendrez comment ce menuest construit dynamiquement.Si le choix du vendeur est 4D V11 SQL Server le dialogue se positionne sur la page 2 du formulaire. Pourassimiler les tables de cette base vous devez soit entrer le nom de publication soit l'adresse IP de la base.

31 / 36

Par exemple saisir "AgendaParticulier:19812" ouvrira la base publiée sous le nom AgendaParticulier etrépondant aux requêtes SQL sur le port 19812.De même la saisie de "10.20.1.94:19812" ouvrira la base publiée à l'adresse IP 10.20.1.94 et répondant auxrequêtes SQL sur le port 19812.

Si le vendeur choisi n'est pas 4D v11 SQL Server le dialogue va en page 3 du formulaire. Vous devez alors choisir le DSN (Data Source Name) dans la liste ; une fois votre choix effectué, le nom dela base apparaît dans la case située sous la liste. Dans le casd'un accès à une base servie par 4D v11 SQLMONOPOSTE, il est normal qu'aucun nom n'apparaisse car cette version ne peut servir qu'une base dedonnée à la fois alors que des serveurs comme MS SQL Server, MySQL et PostgreSQL ont la capacité deservir plusieurs bases de données simultanément. Cependant, si le pilote ODBC utilisé ne supporte pasl'intégration du nom de la base dans le DSN (voir la description de la méthode ASS_GetDataSourceList plushaut), vous devrez saisir ce nom manuellement.

Il ne vous reste plus qu'à saisir le nom d'utilisateur et le mot de passe pour vous connecter.

Le dialogue d'Assimilator

Le dialogue d'assimilation est constitué de 3 pages, les pages 1 et 3 permettant de déterminer les préférencesutilisées lors de l'importation.

page 1 - les tables

C'est ici que vous choisirez les tables à cloner dans la base hôte. Par défaut aucune table n'est cochée. Uneboîte à cocher permet de sélectionner toutes les tables en un seul clic.La colonne "Taille" affiche une estimation de l'espace que chacun des enregistrements occupera. Comme onl'a vu dans la description de la méthodeASS_BytesToUnitOfMeasurecette valeur est calculée sur lescolonnes avec une taille fixe, que cette taille soit déterminée par le type de colonne ou par déclaration. Ellene contient pas d'estimation pour les colonnes de taille variable telles que les colonnes de type BLOB ouTEXT.La colonne "Rangs" affiche le nombre d'enregistrements à assimiler.La partie droite de la fenêtre présente une liste qui affichele détail de la table cliquée qu'elle soit cochée oupas : nom des champs, leurs types et leurs tailles.

Page 1 - Les champs

33 / 36

Par défaut tous les champs sont cochés pour assimilation, Ilest possible de décocher un ou plusieurs champs,mais seulement dans le cas où l'on s'apprête à assimiler une seule et unique table. Dans le cas del'assimilation de plusieurs tables en une seule opération,le logiciel importera systématiquement la totalitédes champs de toutes les tables concernées.

Il apparaît judicieux de faire ici un examen des tables qui pourraient être gourmandes en mémoire. Leschamps qui affichent 0 (zéro) dans la colonne " Taille " peuvent être des BLOB des images, des textes outout autre type pouvant contenir des tailles variables de données. Les champs de type "Sous-table" et"indéfini" ne sont pas pris en charge. Si vous insistez pour les assimiler, une alerte vous informera de ne pasle faire et la boîte à cocher sera désactivée.

Il revient à l'utilisateur de bien comprendre la nature de chaque champ à assimiler.

Page 2 - Prévisualisation des enregistrements

Cette page n'a pour but que de montrer les données à importer.Elle présente 25 enregistrements aumaximum.

Pour savoir comment cette page est construite, reportez-vous à la méthodeASS_GetRecords_Preview.Chaque type de champs est présenté, exceptés les enregistrements de type binaire tels que les BLOBs etImages.

Page 3 - Préférences

La page 3 gère les préférences d'importation. Il faut savoirque si vous n'importez pas de données, seuls leschoix du haut de l'écran sont applicables, dans le cas contraire les deux groupes de texte du bas deviennentopérationnels.

35 / 36

Si vous choisissez "Créer une nouvelle table", une alerte demandant de préciser un nouveau nom pour latable à créer apparaîtra lors de la détection d'une table déjà existante portant le même nom. Si lors de cedialogue vous cliquez sur le bouton "annuler", le process d'assimilation sera interrompu et seules les tablescréées avant l'annulation seront conservées.

Le curseur en bas de page permet d'ajuster le nombre d'enregistrements à traiter par cycle en tenant comptedes valeurs affichées du nombre d'enregistrements et de la taille affichés en page 1.

Si vous n'arrivez pas à régler cette valeur via le curseur, ilsuffit de cliquer sur le cadenas ce qui permetd'éditer les données directement à l'aide du clavier.

Enfin, si vous avez coché la case "Tout sélectionner" de la page 1, Assimilator bouclera sur l'ensemble destables et fixera le nombre d'enregistrements par cycle à la plus grande valeur qu'il aura pu calculer.

Note : le fait de choisir l'option "supprimer la table existanteet en créer une nouvelle" détruira toutes lesdonnées de la table supprimée.

Conclusion

Le composant 4Dv 11 SQL Assimilator permet aux développeursde migrer facilement et rapidement desbases existantes vers une base 4D v11 SQL hôte. L'utilisation du composant est simple, quelques clicssuffisent à intégrer une base externe à l'intérieur d'une base 4D v11 SQL.