Las sentencias SQLJ se pueden entremezclar con sentencias Java en un archivo SQLJ.
Las sentencias SQL estáticas en SQLJ aparecen en cláusulas SQLJ. El conversor de SQLJ reconoce cláusulas SQLJ, ya que empiezan con la señal #sql y terminan con un punto y coma.
Las cláusulas SQLJ más simples son cláusulas ejecutables formadas por la señal #sql seguida de una sentencia SQL entre llaves. Por ejemplo, la siguiente cláusula SQLJ puede aparecer siempre que, legalmente, pueda haber una sentencia Java. El objetivo de la cláusula SQLJ es suprimir todas las filas de la tabla MYTABLE:
#sql { DELETE FROM MYTABLE };
Los argumentos para sentencias SQL incorporadas se pasan mediante variables del sistema principal, que son variables Java que aparecen en la sentencia SQL. Las variables del sistema principal constan de tres partes:
Un identificador Java puede aparecer varias veces en el código Java que se genera para sustituir una cláusula SQLJ.
La consulta siguiente contiene la variable del sistema principal, :x, que es la variable, campo o parámetro Java x visible en el ámbito que contiene la consulta:
SELECT COL1, COL2 FROM TABLE1 WHERE COL3 < :x
Todas las variables del sistema principal que se especifican en SQL compuesto son variables del sistema principal de entrada predeterminada. Debe especificar el identificador de modalidad del parámetro OUT o INOUT antes de la variable del sistema principal para marcarlo como variable del sistema principal de salida. Por ejemplo:
#sql {begin compound atomic static select count(*) into :OUT count1 from employee; end compound}
En una cláusula SQLJ ejecutable, las señales que aparecen dentro de las llaves son señales de SQL, excepto las variables del sistema principal, que corresponden a variables Java. Las variables del sistema principal deben ir precedidas del carácter de dos puntos (:). Las señales de SQL nunca se encuentran fuera de las llaves de una cláusula SQLJ ejecutable.
Por ejemplo, el siguiente método Java inserta los valores de sus argumentos en una tabla de SQL. El cuerpo del método consta de una cláusula SQLJ ejecutable que contiene las variables del sistema principal x, y y z:
void m (int x, String y, float z) throws SQLException { #sql { INSERT INTO TAB1 VALUES (:x, :y, :z) }; }
No inicialice sentencias SQL estáticas en un bucle. Debe existir una sentencia para cada sentencia SQL estática. Por ejemplo, el siguiente fragmento de código no es válido:
for( int i=0; i<2; i++ ){ #sql [ctx] itr[i] = { SELECT id, name FROM staff }; }
Reemplace el fragmento de código anterior por las siguientes sentencias:
int i=0; #sql [ctx] itr[i] = { SELECT id, name FROM staff }; i=1; #sql [ctx] itr[i] = { SELECT id, name FROM staff };
Por lo general, las señales de SQL no son sensibles a mayúsculas y minúsculas (excepto los identificadores que están delimitados por comillas) y se pueden escribir en mayúscula, minúscula o ambas combinadas. Sin embargo, las señales Java sí son sensibles a mayúsculas y minúsculas. Para que los ejemplos de los temas de ayuda de SQLJ sean más claros, las señales de SQL que no son sensibles a mayúsculas y minúsculas aparecen en mayúscula, y las señales Java aparecen en minúscula o ambas combinadas. El valor nulo en minúscula representa el valor nulo de Java, y el valor NULL en mayúscula representa el valor nulo de SQL.