Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Tutorial depuración código plsql con Sqldeveloper

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 27 de abril de 2020 por David C.

117 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, voy a hacer un tutorial para explicar el tema de depuración que lo habéis pedido algunos. 00:00:00
Voy a hacer la depuración de una función de un disparador y luego voy a coger un trozo de código 00:00:12
y lo que voy a hacer es meterlo en un procedimiento y hacer la depuración. 00:00:19
Bien, mirad, lo primero de todo para poder hacer la depuración necesitamos tener unos permisos, entonces yo lo que voy a hacer es que voy a entrar aquí como usuario system y voy a conceder esos dos permisos y los dos permisos son estos que veis aquí que son el debug connect session y el debug any procedure, los dos para el usuario, ¿vale? 00:00:23
Entonces, lo que voy a hacer es que voy a entrar aquí, me voy a conceder ese permiso, me voy a conceder este otro permiso. 00:00:49
Si en estos dos permisos en la base de datos no podemos hacer la depuración del código. 00:00:58
¿De acuerdo? Entonces, de esta manera ya tengo los dos permisos. 00:01:04
Y ahora lo que voy a hacer es, lo primero de todo es depurar la función. 00:01:09
Entonces, para depurar la función, lo que voy a hacer es que voy a coger una función de las que tengo aquí, ¿vale? 00:01:13
La función está, que el otro día estuvimos viendo un poco, que al final no terminé de compilarlo con el disparador. 00:01:20
Y lo que voy a hacer es que le voy a dar aquí a copiar la función. 00:01:27
Me voy al developer. 00:01:35
Vale, la copio. 00:01:38
La copio y la función. 00:01:44
Solamente quiero la función. 00:01:45
A ver. 00:01:47
Solamente quiero la función. 00:01:49
La pongo aquí. 00:01:51
Y la compilo. 00:01:54
y entonces a partir de este momento, aquí en las funciones, me aparece la función ExisteClave. 00:01:56
Esto es una función y entonces como tal, vemos que recibe un parámetro y tiene que devolver un error 00:02:02
y entonces es lo que vamos a intentar depurar. 00:02:07
Bien, entonces para ello, una vez que ya hemos hecho esto, pinchamos en el propio nombre de la función 00:02:13
y nos sale esta pantalla que veis aquí ahora. 00:02:20
entonces 00:02:25
yo voy a hacer lo siguiente 00:02:27
mirad, aquí en ejecutar 00:02:30
tenemos 00:02:33
las opciones 00:02:34
que tenemos de poner puntos de ruptura 00:02:36
de quitar puntos de ruptura y demás, mirad, yo he puesto 00:02:38
el punto de ruptura, si le damos 00:02:40
a F5 00:02:42
lo ponemos, el punto de ruptura 00:02:43
o lo quitamos, lo pongo el punto de ruptura 00:02:46
y puedo poner otro punto de ruptura aquí 00:02:48
vale, entonces si yo lo pongo aquí 00:02:50
en el begin, pues se va a parar ahí 00:02:52
la ejecución de la función y yo voy a poder ir viendo 00:02:53
las líneas. Entonces, al principio lo voy a poner ahí, voy a quitar 00:02:57
esta línea de aquí. Bien, y ahora lo que voy a hacer es darle a este 00:03:01
icono de aquí, ¿vale? Aquí tenéis una opción que es 00:03:05
compilar para depuración también, ¿vale? Entonces, ahora lo que voy a hacer es darle 00:03:09
al bichito este que es para depurar. Mirad, aparece esta ventana 00:03:12
y en esta ventana lo que me permite es introducir 00:03:18
el valor de entrada para la función. Es decir, yo puedo testear esta función dándole distintos valores. 00:03:21
Esta función en concreto lo que hace es que si nos vamos al código, lo que vemos es que lanza una 00:03:29
seller contra la tabla de instrumentos. Entonces yo voy a abrir la tabla de instrumentos. 00:03:38
A ver, un segundín antes de hacer la depuración. Voy a abrir la tabla de instrumentos y aquí voy a ver 00:03:43
los códigos que tienen los instrumentos 00:03:51
porque es con lo que trabaja la función 00:03:54
entonces me voy otra vez a la pestaña de la función 00:03:55
le doy a depurar 00:03:57
y por ejemplo 00:03:59
uno de los códigos que yo tenía 00:04:02
era el valor 1, 2, 3 00:04:03
a ver 00:04:05
perdón 00:04:08
aquí, en el valor de entrada 00:04:10
pincho y ahora voy a meter el valor 00:04:11
1, 2, 3, vale, le doy a aceptar 00:04:14
bueno, ahora aquí me pide 00:04:16
me pide la contraseña 00:04:18
de la conexión, no, esto 00:04:21
creo que hay un modo de evitarlo 00:04:24
vale, y mirad, ahora mismo se ha parado 00:04:25
en el punto de ruptura, entonces yo, para seguir 00:04:28
avanzando línea a línea 00:04:30
lo que tengo que pulsar es sobre F8 00:04:32
entonces pulso sobre F8 00:04:33
bien, si le doy aquí a datos 00:04:36
lo que estoy 00:04:37
viendo es el valor de 00:04:39
las variables, vale, entonces hemos 00:04:41
abierto el cursor 00:04:43
ahora entramos en el 00:04:44
bucle del cursor, recuperamos 00:04:47
la primera línea, 00:04:49
¿vale? Entonces, si os dais cuenta, 00:04:52
lo que voy, las variables 00:04:55
que yo tengo aquí son nada más que el 00:04:57
cursor. Entonces, 00:04:59
el cursor y el 00:05:02
valor de la i, mirad, 00:05:05
el i, lo que 00:05:07
recupero con el cursor lo estoy guardando en la 00:05:09
variable i, 00:05:11
¿vale? Que la variable i es de 00:05:13
tipo campo código de la tabla 00:05:15
Entonces yo le doy a F8, voy pasando así, vais dando cuenta de las vueltas, o sea, vamos dando vueltas y demás. Ahora ya, si ejecuto esta línea, me doy cuenta de que el número de columnas que me ha devuelto el cursor es cero. 00:05:17
entonces estoy 00:05:42
cerrando, es mayor que 0 00:05:44
perdón, luego ha recuperado 00:05:46
vale, y entonces fijaros que 00:05:47
lo que hacemos es que estamos devolviendo 00:05:50
un valor verdadero, sigo aquí 00:05:52
con F8 y ya ha terminado la función 00:05:54
fijaros que se ha ido a la última 00:05:56
línea, bien, si yo lo doy aquí a ejecutar 00:05:58
y le doy a reanudar 00:06:00
volvemos a partir de 0, voy a 00:06:01
volver a hacer la depuración, ahora voy a inventarme 00:06:04
un código, pues el 777 00:06:06
que no está ahí, vale, entonces 00:06:08
me voy a ir aquí, le doy a 00:06:09
otra vez a depurar, ahora en el valor de entrada 00:06:12
fijaros que se ha quedado ya antes, voy a darle el valor 7, 7, 7 00:06:16
le doy a aceptar, me pide otra vez la clave 00:06:20
esto es lo que os digo, creo que de alguna manera, de que no la pida 00:06:24
siempre, pero bueno, en cualquier caso, le doy a F8, se ha parado en el punto de ruptura 00:06:28
le doy a F8, entro aquí 00:06:31
ahora me he salido, fijaros que no ha dado ninguna vuelta al bucle, va a valorar 00:06:35
eso, no ha devuelto ninguna fila, se sale del if, es decir, no ha devuelto ninguna fila 00:06:42
que coincida con esa clave y entonces sacamos el cursor y ahora lo que estamos devolviendo 00:06:47
es el valor falso. Y fijaros aquí abajo cómo se ve que el valor que ha devuelto es el valor 00:06:52
falso. Ahora lo que voy a hacer es con un trozo de código normal y corriente. Con un 00:07:00
trozo de código, yo tengo aquí 00:07:09
por ejemplo el de ejemplo tablas, entonces yo 00:07:11
lo que recomiendo es meter esto en un procedimiento 00:07:13
para si queremos depurarlo 00:07:15
entonces copiamos el código 00:07:17
nos vamos a 00:07:19
aquí y si le damos a procedimientos 00:07:21
le damos al botón 00:07:23
derecho sobre procedimientos 00:07:25
vale, nuevo procedimiento 00:07:27
le damos un nombre, pues lo vamos a llamar 00:07:29
test porque es un procedimiento que 00:07:31
vamos a utilizar para testear código 00:07:33
y ahora aquí dentro 00:07:35
del begin.jl 00:07:37
Yo lo que hago es copiar el código. Esta línea de aquí la quitamos, ¿vale? Porque esa línea no va dentro del procedimiento, el set server o botón lo quitamos y ahora tengo aquí esta opción, ¿vale? Que es compilar y tengo la opción de, perdón, tengo la opción de compilar para depuración, ¿vale? Le damos a compilar para depuración y ahora vamos a ejecutar el código. 00:07:38
Pero antes de ejecutar el código lo que tenemos que hacer es poner un punto de ruptura. Entonces si lo ponemos aquí en el begin, le damos a F5, hemos puesto el punto de ruptura, ahí se va a parar el código durante la depuración. 00:08:03
Y ahora lo que hacemos es que le damos a depurar. Le damos a aceptar, metemos la contraseña para la conexión y ahora se ha parado ahí. ¿De acuerdo? Entonces, si yo ahora voy pasando con el... a ver, la contraseña la he cogido mal, me está avisando aquí. 00:08:14
vamos a darle otra vez a depurar 00:08:43
a ver, ha tenido la mayúscula activada 00:08:45
vale, ahora mira, se ha parado 00:08:50
en el punto de ruptura, tengo aquí 00:08:55
los datos de las 00:08:57
de las variables 00:08:59
de acuerdo 00:09:00
a ver 00:09:02
ahora le voy 00:09:04
dando F8 00:09:07
me va diciendo los valores 00:09:08
que va tomando la M 00:09:11
me va diciendo el valor que va tomando 00:09:13
la I, fijaros 00:09:15
¿Veis? Es el primero que ha recuperado, me dice que es el de ID 1111 00:09:17
Estoy aquí en esta parte del ratón que veis 00:09:24
Si lo de F8 se incrementa el contador 00:09:26
Ahora la M vale 2 00:09:30
Entonces entramos en el bucle 00:09:34
Ahora ha leído nuevo, fijaros aquí, ha leído nuevo 00:09:36
Uno nuevo y así sucesivamente 00:09:39
Y voy dándole vueltas al bucle y viendo cómo van cambiando las variables 00:09:42
Bien, y si quiero en un momento determinado parar, porque ya he depurado el código, le doy aquí a F9, reanudar en NAMP y ya está. 00:09:46
Bien, y ahora para finalizar, lo que quiero hacer es depurar un disparador, ¿de acuerdo? 00:09:54
Entonces voy a cerrar esto. 00:10:01
Yo tengo aquí un disparador ya preparado. 00:10:03
Si no, en cualquier caso, os vais aquí a la parte izquierda de la pantalla y aquí veis los disparadores que hay. 00:10:06
Yo lo voy a cerrar. 00:10:11
este, quiero hacer 00:10:12
el de insertar 00:10:14
nuevas nacionalidades, le doy aquí al código 00:10:16
bien, me aparece, este ya está 00:10:18
compilado y demás, pues si no igual le daríamos aquí 00:10:20
para compilar, para depuración, bien, tiene un punto 00:10:22
de ruptura puesto aquí, yo el 00:10:24
punto de ruptura, este de aquí lo voy a quitar 00:10:26
con el F5, pongo y quito puntos 00:10:28
de ruptura y aquí de nuevo 00:10:30
le doy con el F5 para ponérmelo 00:10:32
en el BGIT y entonces lo que voy a hacer es 00:10:34
depurarlo 00:10:36
vale 00:10:38
entonces, importante ahora 00:10:39
lo siguiente, mirad, aquí me pone los valores de entrada 00:10:42
y me sale aquí la línea que se intenta insertar en la tabla 00:10:45
de músicos que es lo que va a hacer que salte 00:10:50
el disparador, entonces yo lo que tengo que hacer aquí es escribir los valores 00:10:52
que quiero, vale, vamos a meter una nacionalidad 00:10:58
y aquí, esto es la experiencia 00:11:03
vamos a meter un valor numérico y por último el instrumento, subliterar 00:11:09
una cadena y lo 00:11:12
meto de esta 00:11:14
manera, de acuerdo 00:11:15
voy a cambiar la clave porque 00:11:18
es una con la que he estado probando antes, no vaya a ser 00:11:20
que este 00:11:23
que se repita, y ahora lo que hago 00:11:24
es que le doy a aceptar, o sea, importante 00:11:26
cuando le he dado de pura al disparador me sale esta 00:11:28
ventana y aquí, donde pone bloque 00:11:30
PLSQL, aquí como lo que vamos 00:11:32
a hacer es una inserción en la tabla músico, lo que yo 00:11:34
puedo hacer es meter los valores 00:11:36
de los cuatro campos, en este caso 1, 2, 3 00:11:38
4, 5, 1, 2, 3, 4, 5 00:11:41
que quiero insertar, que quiero 00:11:43
probar con el disparador, entonces le doy a aceptar 00:11:45
metemos la contraseña 00:11:47
¿vale? y fijaros que se ha 00:11:49
parado en el punto de ruptura 00:11:54
que yo le he puesto, que es el begin del código 00:11:56
¿vale? entonces si nos vamos por aquí 00:11:58
hacemos un 00:12:00
un F8, fijaros 00:12:02
antes de darle al cursor 00:12:04
si le damos aquí a new 00:12:05
y acordaros que en un disparador 00:12:08
cuando hacemos referencia con dos puntos 00:12:10
new, lo que estamos indicando son 00:12:12
los valores del registro que queremos insertar. 00:12:14
En este caso, como no es una modificación, es de lo único que nos tenemos que preocupar. 00:12:19
Bien, si le doy a F8, abro el cursor, de acuerdo, entonces aquí en total, fijaros que, bueno, todavía no he ejecutado esta línea, 00:12:26
ejecuto esta línea y ahora 00:12:39
lo que estoy guardando en total es 00:12:41
el select count de las nuevas nacionalidades 00:12:43
y tiene cero, quiere decir 00:12:46
que la tabla nuevas nacionalidades no ha 00:12:47
encontrado nada, entonces 00:12:49
metemos por aquí, si total 00:12:51
es cero, eso es cierto y entonces ahora 00:12:53
lo que voy a hacer es insertar en la tabla 00:12:55
nuevas nacionalidades, los valores 00:12:57
que 00:12:59
de la nueva 00:13:00
nacionalidad y el número de valores 00:13:03
¿de acuerdo? y de esta manera 00:13:05
ejecutamos el 00:13:07
disparador 00:13:09
y terminamos. Y esta es la 00:13:10
manera, poniendo puntos de ruptura, la 00:13:13
manera que tenéis para poder 00:13:15
depurar el código. Ya digo, si 00:13:17
tenemos trozos de código 00:13:19
que no vayan, o sea, que estén 00:13:20
en un bloque principal, lo que podemos hacer es crear 00:13:23
un procedimiento que se llama test, 00:13:25
los metemos ahí y ahí podemos poner 00:13:27
un punto de ruptura y ir probando 00:13:29
el código línea a línea. Bueno, pues 00:13:30
espero que esto os haya resultado de 00:13:33
utilidad. 00:13:35
Gracias. 00:13:37
Autor/es:
David Chiclana Abad
Subido por:
David C.
Licencia:
Dominio público
Visualizaciones:
117
Fecha:
27 de abril de 2020 - 19:29
Visibilidad:
Público
Centro:
IES ALONSO DE AVELLANEDA
Duración:
13′ 39″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
32.57 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid