339906_it-IT

liliconcom

SQL personalizzato e Eval / Parse (e \! \! \! ...)

Ciao!

Eseguo molte query che non possono utilizzare il generatore di query JMP e devono essere scritte in SQL Custom.
Ma poiché voglio anche generalizzare il mio codice, devo integrare molti eval / insert e \!

Ecco un esempio:

 

Codice non ancora generalizzato

New SQL Query(
 Connection(
  "ODBC:blabla"
 ),
 QueryName( "v_test_run" ),
 CustomSQL(
  "SELECT \!"t1\!".lot_id 
  FROM \!"public\!".\!"v_test_run\!"  \!"t1\!" 
  WHERE  (  (  ( \!"t1\!".test_run_timestamp >= '2020-11-01 15:25:11' )  )  ) ;"
 )
) << Modify;

Codice generalizzato per includere una data:

gbStr = Eval Insert("

New SQL Query(
 Connection(
  \!"ODBC:blabla\!"
 ),
 QueryName( \!"v_test_run\!" ),
 CustomSQL(
  \!"SELECT \!\!\!"t1\!\!\!".lot_id 
FROM \!\!\!"public\!\!\!".\!\!\!"v_test_run\!\!\!"  \!\!\!"t1\!\!\!" 
WHERE  (  (  ( \!\!\!"t1\!\!\!".test_run_timestamp >= '^date_deb^' )  )  ) ;\!"
)
) << Modify;


");
Eval( Parse( gbStr ) );

C'è qualche altro metodo che mi eviterebbe di dover destreggiarsi con questi \! \! \! simboli?

Su script complessi è davvero difficile da gestire ed eseguire il debug!

 

Grazie

ScriptingRi: SQL personalizzato e Eval / Parse (e \! \! \! ...)

Ci sono alcune opzioni descritte in Questo articolo , Ti consiglio di iniziare con Eval (Eval Expr ()) e poi avvolgere ogni pezzo che devi sostituire con Expr ().Potrebbe assomigliare a questo:

 

Eval( Eval Expr(
 New SQL Query(
  Connection(
   "ODBC:blabla"
  ),
  QueryName( "v_test_run" ),
  CustomSQL(
   "\[SELECT "t1".lot_id 
   FROM "public"."v_test_run"  "t1" 
   WHERE  (  (  ( "t1".test_run_timestamp >= ']\" || datevariable || "\[' )  )  ) ;]\"
  )
 ) << Modify
) );

 

 

Ri: SQL personalizzato e Eval / Parse (e \! \! \! ...)

Grazie mille! Avevo letto questo articolo e avevo provato, ma ho ancora difficoltà a padroneggiare questo eval (eval expr (expr))

Ri: SQL personalizzato e Eval / Parse (e \! \! \! ...)

Vorrei utilizzare i delimitatori \ [e] \ per includere virgolette doppie nella stringa.  

date_deb = "to_date('01-Mar-2019', 'dd-mon-yyyy')";
gbStr = Eval Insert("\[
New SQL Query(
 Connection(
  "ODBC:blabla"
 ),
 QueryName( "v_test_run" ),
 CustomSQL(
  "SELECT "t1".lot_id 
FROM "public"."v_test_run"  "t1" 
WHERE  (  (  ( "t1".test_run_timestamp >= ^date_deb^ )  )  ) ;"
)
) << Modify;
]\");

write(gbstr);

Eval( Parse( gbStr ) );

Produzione:

New SQL Query(
 Connection(
  "ODBC:blabla"
 ),
 QueryName( "v_test_run" ),
 CustomSQL(
  "SELECT "t1".lot_id 
FROM "public"."v_test_run"  "t1" 
WHERE  (  (  ( "t1".test_run_timestamp >= to_date('01-Mar-2019', 'dd-mon-yyyy') )  )  ) ;"
)
) << Modify;

Ri: SQL personalizzato e Eval / Parse (e \! \! \! ...)

Sono d'accordo sul fatto che questa sintassi sia ovvia solo una volta che la capisci, e anche allora crea confusione.Check-out questo elemento della lista dei desideri per introdurre una funzione Eval Expr First (), forse sarebbe più intuitivo?

Ri: SQL personalizzato e Eval / Parse (e \! \! \! ...)

Mi piace seguire un percorso diverso evitando combinazioni di eval parse non intuitive, dove le trovo abbastanza utili per altri scopi.

Spesso ho query complesse (costruite in SQL semplice da altri strumenti come sviluppatori SQL). E ho bisogno di modificare alcune variabili.

 

L'esempio allegato mostra come funziona con datatable di grande classe, tuttavia funzionerebbe per tutte le connessioni ODBC in modo simile.

Semplicemente preparo la mia stringa di connessione (qui non utilizzata) e la query SQL in una variabile stringa, data all'oggetto "New SQL Query".

Uso "assign" (invece di "=") perché funziona bene per query di grandi dimensioni e piegatura del codice.

E sono più flessibile anche per l'utilizzo della funzione di database aperto o per l'elaborazione dell'SQL in altri modi.

Di solito le virgolette doppie non sono necessarie in un semplice SQL (e cerco di evitare anche), a meno che tu non abbia nomi con spazi ecc. Come "Big Class".

 

Names Default To Here( 1 );

cdt = Open( "$Sample_Data\Big Class.jmp" );
age = "15";

// define custom SQL with placeholder
Assign( sql_str, "SELECT t1.name, t1.age, t1.sex, t1.height, 
 t1.weight 
FROM \!"Big Class\!"  t1 
WHERE  (  (  ( t1.age IN  ( &age )  )  )  ) ;" );

// fill placeholder
Substitute Into( sql_str, "&age", "15" );

// execute query
dt_age = New SQL Query( Version( 130 ), Connection( "JMP" ), JMP Tables( cdt ), QueryName( "aged" || "_" || age ), CustomSQL( sql_str ) ) << Run;

Ri: SQL personalizzato e Eval / Parse (e \! \! \! ...)

Fantastico, è davvero molto utile! E poiché abbiamo appena creato il database e io ero l'attore principale di questa creazione, mi sono solo assicurato che nessun nome di tabella o nome di variabile abbia parentesi o spazi, quindi dovrebbe semplificare questa generalizzazione.