La diferencia entre SQL estático y SQL dinámico y ejemplos de prueba

Los llamados aspectos dinámicos y estáticos de SQL se refieren a cuándo se compilan y ejecutan las declaraciones SQL. Ambos se utilizan en la programación integrada de SQL.

SQL estático: en un lenguaje de alto nivel, si una declaración SQL está incrustada y la estructura principal de la declaración SQL es clara, por ejemplo, en un fragmento de código en c, hay un SQL para ejecutar "select * from t1 where c1gt;5", durante la etapa de compilación, este SQL se puede entregar al sistema de administración de la base de datos para su análisis. El software de la base de datos puede realizar un análisis de sintaxis en este SQL y generar código ejecutable para la base de datos. Este SQL se llama SQL estático. Es decir, puede determinar qué hará la base de datos durante la fase de compilación.

SQL dinámico: si el SQL incorporado no se proporciona explícitamente, como definir un nombre de variable de tipo matriz de caracteres en c: char name[32];, entonces use el método de ejecución del objeto Statement preparado para ejecutar Este sql, el valor de este sql puede ser igual a un SQL leído desde el cuadro de texto o un SQL ingresado desde el teclado, pero no se puede determinar qué es específicamente en el momento de la compilación. Solo se puede determinar durante el proceso de ejecución. cuando el programa se está ejecutando. Este tipo de SQL se llama SQL dinámico. Por ejemplo, cada software de base de datos tiene una interfaz que puede ejecutar declaraciones SQL. El SQL recibido por esa interfaz es SQL dinámico, porque el fabricante de la base de datos no sabe qué SQL ingresará el usuario al crear esta interfaz. el SQL recibido Solo después de recibir la entrada real del usuario se puede saber qué es SQL.

Nota: Si algunos parámetros no están determinados en SQL, como "select * from t1 donde c1gt;? and c2#includelt; stdio.hgt;

#includelt; stdlib. hgt;

#includelt;string.hgt;

#includelt;unistd.hgt;

EXEC SQL INCLUDE SQLCA;

EXEC SQL INCLUDE SQLDA;

/*Esta función pertenece a la programación de SQL estático*/

int DBSelect_static(){

EXEC SQL BEGIN DECLARE SECTION;

char _typename[32];

short _length;

EXEC SQL END DECLARE SECTION

EXEC SQL SELECT tipo, longitud

INTO: _typename,: _length

FROM syscat.columns

WHERE tabname='SYSCOLUMNS' y colname='DEFAULT'

printf(" typename :slength:d\n",_typename,_length);

}

/*Esta función pertenece a la programación SQL estática: especifique los parámetros de la función como variables de la declaración SQL*/

int DBSelect_static_param(char *tbl_str, char *col_str){

EXEC SQL BEGIN DECLARE SECTION;

char _typename1[32];

short _length1;

EXEC SQL END DECLARE SECTION

EXEC SQL SELECT tiponombre, longitud

INTO :_typename1, :_length1

FROM syscat .columns

DONDE tabname='tbl_str' y colname='col_str';

printf("typename: slength: d\n", _typename1, _length1); /p>

}

/*Esta función pertenece a la programación SQL dinámica: la estructura de la declaración SQL es incierta y la declaración SQL debe completarse de acuerdo con la entrada del usuario*/

int BD

Update_dynamic(){

EXEC SQL COMENZAR DECLARAR SECCIÓN;

char _address1[32];

char _tablename[32];

char _tmp[32];

char buf[256];

EXEC SQL END DECLARE SECTION;

EXEC SQL SELECT count(address1) INTO: _tmp FROM cisaddressinfo WHERE customid='100000100000000000178';

if(0==_tmp) {printf("¡No encontrado!\n"); return -1;}

memset(buf, 0x00, sizeof(buf));

sprintf(buf, "actualizar ");

printf("Por favor, ingrese: nombre de tabla -gt;"); > scanf("s",&_tablename);

strcat(buf,_tablename);

strcat(buf, "set dirección1=? donde customid='1000001000000000000178'") ;

EXEC SQL PREPARAR proyecto DESDE: buf

if(sqlca.sqlcode) perror("PREPARE");

printf("Por favor, ingrese: dirección1 -gt ;");

scanf("s",amp;_address1);

EXEC SQL EJECUTAR proyecto USANDO:_address1;

if(sqlca. sqlcode) perror("EJECUTAR");

EJECUTAR TRABAJO DE COMUNICACIÓN SQL

if(sqlca.sqlcode) perror("COMMITIR"); >

/*Esta función pertenece a la programación de SQL dinámico: uso de la estructura de datos sqlda para ensamblar SQL dinámico complejo y modificable*/

int DBSelect_dynamic(){

EXEC SQL BEGIN DECLARE SECTION;

char hostVarStmt[256];

EXEC SQL END DECLARE SECTION;

// Declara dos punteros SQLDA, minsqlda será la estructura SQLDA más pequeña, utilizado para la instrucción PREPARE,

// El número de campos en el conjunto de resultados se desconoce en este momento, por lo que solo se necesita un SQLDA mínimo, que contiene HEADER y una estructura SQLVAR

s

qlda * minsqlda = (struct sqlda*)malloc(SQLDASIZE(1));

struct sqlda * fulsqlda = NULL

strcpy(hostVarStmt, "seleccione WUID del proceso de trabajo donde muid = '185001'");

// PREPARE completará el encabezado de minsqlda, sqldabc es la longitud total de SQLDA, sqln es el número de SQLVAR, es decir, el número de campos

EXEC SQL PREPARE STMT INTO: * minsqlda FROM: hostVarStmt;

// Asigne la estructura SQLDA completa fulsqlda según la longitud obtenida de minsqlda, que incluirá el número apropiado de estructuras SQLVAR

// Miembros de la estructura sqlda La variable sqld devuelve el número de campos en la instrucción de consulta seleccionada. La memoria se puede asignar de acuerdo con esta variable

fulsqlda = (struct sqlda *)malloc(SQLDASIZE. (minsqlda-gt; sqld));

// Utilice la instrucción DESCRIBE para obtener la información de descripción de cada campo en el conjunto de resultados, incluido el tipo (sqltype) y la longitud (sqllen) de cada campo

EXEC SQL DESCRIBIR STMT EN: *fulsqlda;

int i

for(i=0; ilt; minsqlda-gt; sqld; i )

{

// Según el valor de cada campo Longitud, asigna memoria y almacena la dirección en sqldata correspondiente a SQLVAR

// fulsqlda-gt; [i].sqldata=malloc(fulsqlda-gt; sqlvar[i].sqllen);

fulsqlda-gt; sqlvar[i].sqldata=malloc(32); p> fulsqlda-gt; sqlvar[i].sqlind=malloc(sizeof(short));

}

// Declarar cursor

EXEC SQL DECLARE c1 CURSOR PARA STMT;

EXEC SQL OPEN c1;

EXEC SQL CUANDO no se encuentra goto no_more_data;

// Lee el registro y el contenido de cada uno El campo en el registro se escribirá en la memoria apuntada por sqldata de la estructura SQLVAR correspondiente en fulsqlda

// EXEC SQL FETCH c1 USING DESCRIPTOR: *fulsqlda

// Bucle para leer todos los registros

for (;;)

{

EXEC SQL FETCH c1 USANDO EL DESCRIPTOR: *fulsqlda

for( i=0;

; minsqlda-gt; sqld; i ){

printf("d s\n", fulsqlda-gt; sqlvar[i].sqltype, fulsqlda-gt; sqlvar[i].sqldata

usleep(10000);

}

}

devuelve 0;

no_more_data:

printf("\nFIN de datos\n");

free(minsqlda);

free(fulsqlda

EXEC SQL CLOSE c1;

return 0;

}

int main(){

/*Conectar a la base de datos*/

EXEC SQL CONECTARSE AL USUARIO ezeelink USANDO EA704075ezeelink;

DBSelect_static()

DBSelect_static_param("SYSCOLUMNS", "DEFAULT"); ;

DBSelect_dynamic();

no_more_data:

devuelve 0; >

Los resultados de salida del caso son los siguientes:

nombre de tipo: VARCHARlength: 254

nombre de tipo: VARCHARlength: 254

Por favor, ingrese: nombre de tabla -gt; cisaddressinfo

Introduzca: dirección1 -gt; ShangHai

452 cis505

452 cis506

452 pub806

452 ips007

452 ips032

452 dps302

FIN de datos

Nota:

Si use programación SQL dinámica para escribir declaraciones de consultas seleccionadas y guardar los resultados, necesita usar la estructura de datos sqlda y usar las características y funciones de SQL, tales como: PREPARAR, EJECUTAR, DESCRIBIR, DECLARAR CURSE C1 PARA…, ABRIR CURSE, CERRAR MALDICIÓN... etc.

Sugerencias:

SQL dinámico es adecuado para situaciones en las que se desconocen el nombre de la tabla y el nombre del campo de consulta. Cuando se conocen el nombre del campo de consulta y el nombre de la tabla, el uso de SQL dinámico (método de empalme de cadenas) aumentará el costo del análisis completo. En este caso, se recomienda utilizar SQL estático, que puede mejorar la eficiencia de la ejecución. No es eficiente utilizar SQL dinámico improvisado durante el proceso. A veces es mejor pasar el SQL directamente al programa, que se compila y vincula de antemano, mientras que el SQL dinámico se compila y vincula solo después de la ejecución.