242411_fr-FR

liliconcom

Générer des variables de poignées de tables de données avec une boucle

Salut à tous,

 

 

J'ai écrit la boucle pour exécuter la table de données SQL () avec plusieurs noms de table. Pour la gestion de la table de données, j'essaie de créer une poignée pour chaque table mais elle a échoué. 

 

Besoin d'aide pour tout le monde sur le code comme ci-dessous

 

sql_code 1 = Expr( "..." );
sql_code 2 = Expr( "..." );
sql_code 3 = Expr( "..." );
list = { "sql_code 1", "sql_code 2", sql_code 3" };
For( k = 1, k <= N Items( list ), k++, 
sub_list = list[k];
Eval list( Parse( "var_" || sub_list )  ) = Execute SQL( database_connection, Eval(Parse(list)), invisible, "Data Table_" || sub_list );
);

Bonne journée

 

 

Re: Générer une variable de poignées de tables de données avec une boucle

@Black_Wheel ,

 

Il y a eu plusieurs problèmes avec votre script.

• Le SQL réel doit être une variable chaîne / caractère.
• Le dernier élément de liste manque un devis.
• Concepts manquants dans la ligne de commande que vous essayez de générer dans la boucle For 

Le côté gauche d'une affectation JMP doit être un Valeur L . En substance, une valeur L doit être un mot ou un nom et non une expression. 

Cependant, je crois que vous essayez de créer une commande JMP où le côté gauche de l'affectation (le côté gauche de est un nom.

 

Ci-dessous, à partir de la fenêtre Journal JMP

Parse(Eval Insert( "\[var_^sub_list^  = Execute SQL( database_connection, ^list[k]^, invisible, "Data Table_^sub_list^")]\" )) ;

/*:

var_sql_code 1 = Execute SQL(
 database_connection,
 sql_code 1,
 invisible,
 "Data Table_sql_code 1"
)

La ligne supérieure génère une expression JMP valide. Si cela est utilisé comme argument pour la fonction Eval () et que votre chaîne de connexion à la base de données et votre code SQL ne contiennent aucune erreur, la requête devrait fonctionner devrait fonctionner.  Voir le script ci-dessous.

 

Pour vous aider à comprendre les fonctions JSL, à partir du menu principal JMP> Aidez-moi > Index de script > Les fonctions , Chercher:

• Insert Eval ()
• Analyser ()
• Eval () et 
• la syntaxe pour Exécuter SQL ()

 

sql_code 1 = "..." ;
sql_code 2 = "..." ;
sql_code 3 = "..." ;
list = { "sql_code 1", "sql_code 2", "sql_code 3" };
For( k = 1, k <= N Items( list ), k++, 
sub_list = list[k];
Eval(Parse(Eval Insert( "\[var_^sub_list^  = Execute SQL( database_connection, ^list[k]^, invisible, "Data Table_^sub_list^")]\" )) ) ;
);

J'espère que cela pourra aider. Bonne chance!

 

Re: Générer une variable de poignées de tables de données avec une boucle

Plutôt que de passer par toutes les machinations pour créer un nom de variable dynamique pour chacune de vos tables de résultats SQL, pourquoi ne pas simplement créer une liste de tables? Surtout si vos instructions SQL sont complexes.

sql_code 1 = Expr( "..." );
sql_code 2 = Expr( "..." );
sql_code 3 = Expr( "..." );
list = { "sql_code 1", "sql_code 2", "sql_code 3" };
dt_list = {};
For( k = 1, k <= N Items( list ), k++, 
 sql_statement = list[k];
 dt_list[k] = Execute SQL( database_connection, sql_statement, invisible, "Data Table_" || char(k) );
);

Si vous souhaitez que l'instruction SQL fasse partie des tables nouvellement créées, vous pouvez l'ajouter en tant que variable de table.

Re: Générer une variable de poignées de tables de données avec une boucle

@Black_Wheel ,

 

Je suis entièrement d'accord avec Pete, @pmroz . Une liste d'expressions, une liste de colonnes / variables, une liste de noms ou de références de tables de données, correspondant à l'ordre des éléments de liste (k), est un code plus facile à lire et à maintenir et je vous recommande de l'utiliser.

 

Re: Générer une variable de poignées de tables de données avec une boucle

Ouais.  @pmroz @ gzmorgan0 une liste est certainement mieux que de simplement analyser une chaîne dans une variable.  

À moins que vous ne fassiez la même chose aux trois tableaux, je ne les mettrais même pas dans une liste.  Je nommerais simplement les variables avec des noms descriptifs.  Le deuxième exemple est moins de lignes, plus facile à comprendre et vous donne des variables nommées afin que vous n'ayez pas à vous rappeler quelle table est 1, 2 et 3.  

Names default to here(1);
sqllist = {
 "SELECT * 
 FROM People", 
 "SELECT * 
 FROM Places", 
 "SELECT * 
 FROM Things"
};
table_names = {"People", "Places", "Things"};
dt_list = {};

for(i=1, i<=nitems(sqllist), i++, 
 dt_list[k] = Execute SQL(dbc, sqllist[i], table_names[i])
);

// vs 

dt_people = Execute SQL(dbc, 
 "SELECT * 
 FROM People", 
 "People"
);

dt_places = Execute SQL(dbc, 
 "SELECT * 
 FROM Places", 
 "Places"
);

dt_things = Execute SQL(dbc, 
 "SELECT * 
 FROM Things", 
 "Things"
);

Si les tables ont toutes le même schéma, j'aurais juste une liste d'instructions sql dans une liste et j'appellerais cela directement.