Bonjour!
J'ai une table de données qui a été produite via un script exécutant deux requêtes distinctes (qui fournissent des données provenant de deux sources différentes) qui sont ensuite fusionnées pour former une table de données. Ma question concerne la mise à jour quotidienne de cette table de manière à ce que le script n'ait pas besoin d'être réexécuté depuis le début et que tout nettoyage/ajustements/nouvelles colonnes puisse être conservé. Je vois sur la barre latérale qu'il y a à la fois une "mise à jour depuis la base de données" et une "mise à jour depuis la base de données2". Je peux en exécuter un, mais cela supprimera les colonnes qui ne sont pas incluses dans cette source (c'est-à-dire que si j'exécute "mise à jour depuis la base de données", qui concerne la première requête, cela supprimera les colonnes TVC, VI, AC et DC à partir de la requête 2 ainsi que d'autres colonnes de calcul/saisie manuelle que j'ajoute au tableau après la fusion dans le script d'origine).
J'ai essayé de copier les deux scripts de mise à jour ensemble dans un seul script (voir ci-dessous), mais j'ai le problème où, lorsqu'il exécute le premier, il essaie de supprimer les colonnes avant d'exécuter le second. Je ne sais pas si la meilleure approche serait de combiner les tables puis d'essayer de mettre à jour ou s'il existe quelque chose de plus simple (peut-être un moyen de le mettre à jour sans supprimer les données qui ne proviennent pas de cette source) ? J'ai supprimé les informations de connexion et modifié les noms dans le code ci-dessous, mais j'espère que cela aide à donner une idée. Quelqu'un a-t-il déjà rencontré un problème similaire ? Merci!
New SQL Query(
Version( 130 ),
Connection(
""
),
QueryName( "query1" ),
Select(
Column( "Assay", "t1" ),
Column( "Experiment", "t1" ),
Column( "Date", "t1", Numeric Format( "m/d/y h:m:s", "0", "NO", "" ) ),
Column( "G", "t1" ),
Column( "L", "t1" ),
Column( "N", "t1" ),
Column( "K", "t1" ),
Column( "C", "t1" ),
Column( "H", "t1" ),
Column( "O", "t1" ),
Column( "C", "t1" ),
),
From( Table( "Runs", Schema( "schema1" ), Alias( "t1" ) ) ),
Where(
Contains(
Column( "Experiment", "t1" ),
"E001",
UI(
Contains(
Base(
"Categorical",
Prompt(
"Experiment ID:",
Character,
PromptName( "t1.Experiment_1" )
)
)
)
)
) & Does Not Contain(
Column( "Assay, "t1" ),
"xxx",
UI(
Contains(
Base(
"Categorical",
Prompt(
"Add a filter for names (optional) or put xxx:",
Character,
PromptName( "t1.AssayId_1" )
)
)
)
)
) & GE(
Column(
"Date",
"t1",
Numeric Format( "m/d/y h:m:s", "0", "NO", "" )
),
0,
UI(
Comparison(
Base(
"Continuous",
Prompt(
"Date range:",
Character,
PromptName( "t1.RunDate_1" )
)
)
)
)
)
)
) << Run Foreground( UpdateTable( Current Data Table() ) );
New SQL Query(
Version( 130 ),
Connection(
""
),
QueryName( "query2" ),
Select(
Column( "Assay", "t2" ),
Column( "Experiment", "t2" ),
Column( "Date", "t2", Numeric Format( "m/d/y h:m:s", "0", "NO", "" ) ),
Column( "TVC", "t2" ),
Column( "VI", "t2" ),
Column( "AC", "t2" ),
Column( "AD", "t2" )
),
From( Table( "Runs", Schema( "schema2" ), Alias( "t2" ) ) ),
Where(
Contains(
Column( "Experiment", "t2" ),
"E001",
UI(
Contains(
Base(
"Categorical",
Prompt(
"Experiment ID:",
Character,
PromptName( "t2.Experiment_1" )
)
)
)
)
) & Does Not Contain(
Column( "Assay", "t2" ),
"xxx",
UI(
Contains(
Base(
"Categorical",
Prompt(
"Add a filter (optional) or put xxx:",
Character,
PromptName( "t2.AssayId_1" )
)
)
)
)
) & GE(
Column(
"Date",
"t2",
Numeric Format( "m/d/y h:m:s", "0", "NO", "" )
),
0,
UI(
Comparison(
Base(
"Continuous",
Prompt(
"Date range:",
Character,
PromptName( "t2.RunDate_1" )
)
)
)
)
)
)
) << Run Foreground( UpdateTable( Current Data Table() ) )
Je suis presque sûr que ce que vous voyez, c'est que si vous ajoutez des colonnes à une table créée à partir d'une nouvelle requête SQL, vous obtiendrez une nouvelle table de données lorsque vous effectuerez une mise à jour à partir de la base de données. Autrement dit, vous ne pouvez pas réutiliser la table importée puisque vous y avez modifié les métadonnées (colonnes ajoutées).
Je pense que ce que vous pouvez faire est d'importer vos 2 tables à partir de la ou des bases de données en utilisant Fichier-> Base de données-> Query Builder (ne pas enregistrer les tables de données). Ensuite, exécutez Tables-> JMP Query Builder pour combiner les 2 tables. . Cela ressemblera à quelque chose comme :
New SQL Query(
Version( 130 ),
Connection( "JMP" ),
JMP Tables(
["Big Class Families" =>
"Source(New SQL Query(
Connection(
""
),
QueryName( \!"Big Class Families\!" ),
Select,
From( Table( \!"Big Class Families\!", Schema( \!"SQBTest\!" ), Alias( \!"t1\!" ) ) )
) << Run Foreground)",
"g4_bigclass" =>
"Source(New SQL Query(
Connection(""),
QueryName( \!"g4_bigclass\!" ),
Select,
From( Table( \!"g4_bigclass\!", Schema( \!"SQBTest\!" ), Alias( \!"t1\!" ) ) )
) << Run Foreground)"
]
),
QueryName( "SQLQuery3" ),
Select(
Column( "picture", "t1" ),
Column( "name", "t1" ),
Column( "age", "t1" ),
Column( "sex", "t1" ),
Column( "height", "t1" ),
Column( "weight", "t1" ),
Column( "sibling ages", "t1" ),
Column( "sports", "t1" ),
Column( "countries visited", "t1" ),
Column( "family cars", "t1" ),
Column( "reported illnesses", "t1" ),
Column( "age vector", "t1" ),
Column( "pet", "t1" ),
Column( "name", "t2", Alias( "name 2" ) ),
Column( "age", "t2", Alias( "age 2" ) ),
Column( "sex", "t2", Alias( "sex 2" ) ),
Column( "height", "t2", Alias( "height 2" ) ),
Column( "weight", "t2", Alias( "weight 2" ) )
),
From(
Table( "Big Class Families", Alias( "t1" ) ),
Table(
"g4_bigclass",
Alias( "t2" ),
Join(
Type( Left Outer ),
EQ( Column( "name", "t2" ), Column( "name", "t1" ) ) &
EQ( Column( "age", "t2" ), Column( "age", "t1" ) ) &
EQ( Column( "sex", "t2" ), Column( "sex", "t1" ) ) &
EQ( Column( "height", "t2" ), Column( "height", "t1" ) ) &
EQ( Column( "weight", "t2" ), Column( "weight", "t1" ) )
)
)
)
) << Run;
Ce qui se passe, c'est que JMP Query Builder extrait le script source de chaque table non enregistrée pour créer son script. Cela signifie que chaque fois que le script Nouvelle requête SQL s'exécute, il introduit de nouvelles données provenant des sources de données dans chacune des tables dépendantes.
