339906_de-DE

liliconcom

SQL Custom und Eval / Parse (und \! \! \! ...)

Hallo!

Ich mache viele Abfragen, die den JMP-Abfrage-Generator nicht verwenden können und in SQL Custom geschrieben werden müssen.
Da ich aber auch meinen Code verallgemeinern möchte, muss ich viele Auswertungen / Einfügungen und \!

Hier ist ein Beispiel:

 

Code noch nicht verallgemeinert

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;

Code Verallgemeinert, um ein Datum einzuschließen:

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 ) );

Gibt es eine andere Methode, die mich davor bewahren würde, mit diesen zu jonglieren? \! \! \! Symbole?

Bei komplexen Skripten ist es wirklich schwierig, damit umzugehen und zu debuggen!

 

Danke

SkriptingBetreff: SQL Custom und Eval / Parse (und \! \! \! ...)

Es gibt einige Optionen, die in beschrieben sind Dieser Beitrag Ich empfehle, mit Eval (Eval Expr ()) zu beginnen und dann jedes Stück, das Sie durch Expr () ersetzen müssen, zu verpacken.Es könnte ungefähr so aussehen:

 

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
) );

 

 

Betreff: SQL Custom und Eval / Parse (und \! \! \! ...)

Vielen Dank! Ich hatte diesen Artikel gelesen und versucht, aber ich habe immer noch Schwierigkeiten, diese Bewertung zu meistern (eval expr (expr))

Betreff: SQL Custom und Eval / Parse (und \! \! \! ...)

Ich würde die Trennzeichen \ [und] \ verwenden, um doppelte Anführungszeichen in die Zeichenfolge aufzunehmen.  

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 ) );

Ausgabe:

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;

Betreff: SQL Custom und Eval / Parse (und \! \! \! ...)

Ich bin damit einverstanden, dass diese Syntax erst dann offensichtlich ist, wenn Sie sie verstanden haben, und selbst dann ist sie verwirrend.Auschecken dieser Wunschzettel Eine Eval Expr First () -Funktion einzuführen, wäre das vielleicht intuitiver?

Betreff: SQL Custom und Eval / Parse (und \! \! \! ...)

Ich mag es, einen anderen Weg zu gehen und nicht intuitive Eval-Parse-Kombinationen zu vermeiden, wo ich sie für andere Zwecke sehr nützlich finde.

Oft habe ich komplexe Abfragen (von anderen Tools wie SQL-Entwicklern in einfachem SQL erstellt). Und ich muss einige Variablen ändern.

 

Das beigefügte Beispiel zeigt, wie es mit Datentabellen großer Klassen funktioniert und wie es für alle ODBC-Verbindungen auf ähnliche Weise funktionieren würde.

Ich bereite einfach meine Verbindungszeichenfolge (hier nicht verwendet) und die SQL-Abfrage in einer Zeichenfolgenvariablen vor, die dem Objekt "Neue SQL-Abfrage" zugewiesen wird.

Ich verwende "zuweisen" (anstelle von "="), weil es für große Abfragen und das Falten von Code gut funktioniert.

Und ich bin flexibler, wenn ich auch die Funktion für offene Datenbanken verwenden oder SQL auf andere Weise verarbeiten möchte.

Normalerweise werden doppelte Anführungszeichen in einer einfachen SQL-Datei nicht benötigt (und ich versuche dies auch zu vermeiden), es sei denn, Sie haben Namen mit Leerzeichen usw. wie "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;

Betreff: SQL Custom und Eval / Parse (und \! \! \! ...)

Großartig, das ist wirklich sehr nützlich! Und da wir gerade die Datenbank erstellt haben und ich der Hauptakteur dieser Erstellung war, habe ich nur sichergestellt, dass kein Tabellenname oder Variablenname Klammern oder Leerzeichen enthält, daher sollte dies diese Verallgemeinerung vereinfachen.