1
00:00:00,820 --> 00:00:11,119
Bueno, voy a hacer un tutorial para explicar el tema de depuración que lo habéis pedido algunos.

2
00:00:12,539 --> 00:00:19,559
Voy a hacer la depuración de una función de un disparador y luego voy a coger un trozo de código

3
00:00:19,559 --> 00:00:23,379
y lo que voy a hacer es meterlo en un procedimiento y hacer la depuración.

4
00:00:23,379 --> 00:00:49,740
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?

5
00:00:49,740 --> 00:00:58,490
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.

6
00:00:58,609 --> 00:01:03,149
Si en estos dos permisos en la base de datos no podemos hacer la depuración del código.

7
00:01:04,530 --> 00:01:09,209
¿De acuerdo? Entonces, de esta manera ya tengo los dos permisos.

8
00:01:09,290 --> 00:01:12,390
Y ahora lo que voy a hacer es, lo primero de todo es depurar la función.

9
00:01:13,590 --> 00:01:20,670
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?

10
00:01:20,670 --> 00:01:26,769
La función está, que el otro día estuvimos viendo un poco, que al final no terminé de compilarlo con el disparador.

11
00:01:27,609 --> 00:01:33,209
Y lo que voy a hacer es que le voy a dar aquí a copiar la función.

12
00:01:35,120 --> 00:01:36,340
Me voy al developer.

13
00:01:38,319 --> 00:01:39,640
Vale, la copio.

14
00:01:44,079 --> 00:01:45,480
La copio y la función.

15
00:01:45,920 --> 00:01:47,640
Solamente quiero la función.

16
00:01:47,959 --> 00:01:48,239
A ver.

17
00:01:49,579 --> 00:01:51,019
Solamente quiero la función.

18
00:01:51,299 --> 00:01:51,959
La pongo aquí.

19
00:01:54,280 --> 00:01:56,579
Y la compilo.

20
00:01:56,579 --> 00:02:02,540
y entonces a partir de este momento, aquí en las funciones, me aparece la función ExisteClave.

21
00:02:02,719 --> 00:02:07,859
Esto es una función y entonces como tal, vemos que recibe un parámetro y tiene que devolver un error

22
00:02:07,859 --> 00:02:11,219
y entonces es lo que vamos a intentar depurar.

23
00:02:13,370 --> 00:02:20,509
Bien, entonces para ello, una vez que ya hemos hecho esto, pinchamos en el propio nombre de la función

24
00:02:20,509 --> 00:02:25,409
y nos sale esta pantalla que veis aquí ahora.

25
00:02:25,409 --> 00:02:27,830
entonces

26
00:02:27,830 --> 00:02:30,629
yo voy a hacer lo siguiente

27
00:02:30,629 --> 00:02:33,090
mirad, aquí en ejecutar

28
00:02:33,090 --> 00:02:34,349
tenemos

29
00:02:34,349 --> 00:02:36,750
las opciones

30
00:02:36,750 --> 00:02:38,409
que tenemos de poner puntos de ruptura

31
00:02:38,409 --> 00:02:40,349
de quitar puntos de ruptura y demás, mirad, yo he puesto

32
00:02:40,349 --> 00:02:42,629
el punto de ruptura, si le damos

33
00:02:42,629 --> 00:02:43,449
a F5

34
00:02:43,449 --> 00:02:46,250
lo ponemos, el punto de ruptura

35
00:02:46,250 --> 00:02:48,349
o lo quitamos, lo pongo el punto de ruptura

36
00:02:48,349 --> 00:02:50,430
y puedo poner otro punto de ruptura aquí

37
00:02:50,430 --> 00:02:52,349
vale, entonces si yo lo pongo aquí

38
00:02:52,349 --> 00:02:53,810
en el begin, pues se va a parar ahí

39
00:02:53,810 --> 00:02:57,949
la ejecución de la función y yo voy a poder ir viendo

40
00:02:57,949 --> 00:03:01,969
las líneas. Entonces, al principio lo voy a poner ahí, voy a quitar

41
00:03:01,969 --> 00:03:05,990
esta línea de aquí. Bien, y ahora lo que voy a hacer es darle a este

42
00:03:05,990 --> 00:03:09,629
icono de aquí, ¿vale? Aquí tenéis una opción que es

43
00:03:09,629 --> 00:03:12,889
compilar para depuración también, ¿vale? Entonces, ahora lo que voy a hacer es darle

44
00:03:12,889 --> 00:03:18,030
al bichito este que es para depurar. Mirad, aparece esta ventana

45
00:03:18,030 --> 00:03:21,810
y en esta ventana lo que me permite es introducir

46
00:03:21,810 --> 00:03:29,270
el valor de entrada para la función. Es decir, yo puedo testear esta función dándole distintos valores.

47
00:03:29,409 --> 00:03:38,370
Esta función en concreto lo que hace es que si nos vamos al código, lo que vemos es que lanza una

48
00:03:38,370 --> 00:03:42,310
seller contra la tabla de instrumentos. Entonces yo voy a abrir la tabla de instrumentos.

49
00:03:43,729 --> 00:03:51,780
A ver, un segundín antes de hacer la depuración. Voy a abrir la tabla de instrumentos y aquí voy a ver

50
00:03:51,780 --> 00:03:54,080
los códigos que tienen los instrumentos

51
00:03:54,080 --> 00:03:55,580
porque es con lo que trabaja la función

52
00:03:55,580 --> 00:03:57,639
entonces me voy otra vez a la pestaña de la función

53
00:03:57,639 --> 00:03:59,639
le doy a depurar

54
00:03:59,639 --> 00:04:02,379
y por ejemplo

55
00:04:02,379 --> 00:04:03,860
uno de los códigos que yo tenía

56
00:04:03,860 --> 00:04:05,680
era el valor 1, 2, 3

57
00:04:05,680 --> 00:04:08,020
a ver

58
00:04:08,020 --> 00:04:10,199
perdón

59
00:04:10,199 --> 00:04:11,300
aquí, en el valor de entrada

60
00:04:11,300 --> 00:04:14,159
pincho y ahora voy a meter el valor

61
00:04:14,159 --> 00:04:16,439
1, 2, 3, vale, le doy a aceptar

62
00:04:16,439 --> 00:04:18,139
bueno, ahora aquí me pide

63
00:04:18,139 --> 00:04:21,860
me pide la contraseña

64
00:04:21,860 --> 00:04:24,000
de la conexión, no, esto

65
00:04:24,000 --> 00:04:25,959
creo que hay un modo de evitarlo

66
00:04:25,959 --> 00:04:28,000
vale, y mirad, ahora mismo se ha parado

67
00:04:28,000 --> 00:04:30,199
en el punto de ruptura, entonces yo, para seguir

68
00:04:30,199 --> 00:04:32,160
avanzando línea a línea

69
00:04:32,160 --> 00:04:33,680
lo que tengo que pulsar es sobre F8

70
00:04:33,680 --> 00:04:36,240
entonces pulso sobre F8

71
00:04:36,240 --> 00:04:37,639
bien, si le doy aquí a datos

72
00:04:37,639 --> 00:04:39,980
lo que estoy

73
00:04:39,980 --> 00:04:41,779
viendo es el valor de

74
00:04:41,779 --> 00:04:43,860
las variables, vale, entonces hemos

75
00:04:43,860 --> 00:04:44,680
abierto el cursor

76
00:04:44,680 --> 00:04:47,779
ahora entramos en el

77
00:04:47,779 --> 00:04:49,839
bucle del cursor, recuperamos

78
00:04:49,839 --> 00:04:50,819
la primera línea,

79
00:04:52,100 --> 00:04:53,600
¿vale? Entonces, si os dais cuenta,

80
00:04:54,980 --> 00:04:55,779
yo

81
00:04:55,779 --> 00:04:57,980
lo que voy, las variables

82
00:04:57,980 --> 00:04:59,879
que yo tengo aquí son nada más que el

83
00:04:59,879 --> 00:05:02,019
cursor. Entonces,

84
00:05:02,339 --> 00:05:05,800
el cursor y el

85
00:05:05,800 --> 00:05:06,740
valor de la i, mirad,

86
00:05:07,060 --> 00:05:09,800
el i, lo que

87
00:05:09,800 --> 00:05:11,459
recupero con el cursor lo estoy guardando en la

88
00:05:11,459 --> 00:05:13,279
variable i,

89
00:05:13,879 --> 00:05:15,720
¿vale? Que la variable i es de

90
00:05:15,720 --> 00:05:17,620
tipo campo código de la tabla

91
00:05:17,620 --> 00:05:42,660
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.

92
00:05:42,660 --> 00:05:44,180
entonces estoy

93
00:05:44,180 --> 00:05:46,540
cerrando, es mayor que 0

94
00:05:46,540 --> 00:05:47,920
perdón, luego ha recuperado

95
00:05:47,920 --> 00:05:50,259
vale, y entonces fijaros que

96
00:05:50,259 --> 00:05:52,519
lo que hacemos es que estamos devolviendo

97
00:05:52,519 --> 00:05:54,600
un valor verdadero, sigo aquí

98
00:05:54,600 --> 00:05:56,420
con F8 y ya ha terminado la función

99
00:05:56,420 --> 00:05:58,339
fijaros que se ha ido a la última

100
00:05:58,339 --> 00:06:00,600
línea, bien, si yo lo doy aquí a ejecutar

101
00:06:00,600 --> 00:06:01,839
y le doy a reanudar

102
00:06:01,839 --> 00:06:04,480
volvemos a partir de 0, voy a

103
00:06:04,480 --> 00:06:06,620
volver a hacer la depuración, ahora voy a inventarme

104
00:06:06,620 --> 00:06:08,319
un código, pues el 777

105
00:06:08,319 --> 00:06:09,740
que no está ahí, vale, entonces

106
00:06:09,740 --> 00:06:12,240
me voy a ir aquí, le doy a

107
00:06:12,240 --> 00:06:16,500
otra vez a depurar, ahora en el valor de entrada

108
00:06:16,500 --> 00:06:20,199
fijaros que se ha quedado ya antes, voy a darle el valor 7, 7, 7

109
00:06:20,199 --> 00:06:24,060
le doy a aceptar, me pide otra vez la clave

110
00:06:24,060 --> 00:06:28,360
esto es lo que os digo, creo que de alguna manera, de que no la pida

111
00:06:28,360 --> 00:06:31,519
siempre, pero bueno, en cualquier caso, le doy a F8, se ha parado en el punto de ruptura

112
00:06:31,519 --> 00:06:35,600
le doy a F8, entro aquí

113
00:06:35,600 --> 00:06:42,449
ahora me he salido, fijaros que no ha dado ninguna vuelta al bucle, va a valorar

114
00:06:42,449 --> 00:06:47,889
eso, no ha devuelto ninguna fila, se sale del if, es decir, no ha devuelto ninguna fila

115
00:06:47,889 --> 00:06:52,970
que coincida con esa clave y entonces sacamos el cursor y ahora lo que estamos devolviendo

116
00:06:52,970 --> 00:07:00,569
es el valor falso. Y fijaros aquí abajo cómo se ve que el valor que ha devuelto es el valor

117
00:07:00,569 --> 00:07:09,709
falso. Ahora lo que voy a hacer es con un trozo de código normal y corriente. Con un

118
00:07:09,709 --> 00:07:11,589
trozo de código, yo tengo aquí

119
00:07:11,589 --> 00:07:13,529
por ejemplo el de ejemplo tablas, entonces yo

120
00:07:13,529 --> 00:07:15,889
lo que recomiendo es meter esto en un procedimiento

121
00:07:15,889 --> 00:07:17,829
para si queremos depurarlo

122
00:07:17,829 --> 00:07:19,670
entonces copiamos el código

123
00:07:19,670 --> 00:07:21,370
nos vamos a

124
00:07:21,370 --> 00:07:23,790
aquí y si le damos a procedimientos

125
00:07:23,790 --> 00:07:25,670
le damos al botón

126
00:07:25,670 --> 00:07:27,029
derecho sobre procedimientos

127
00:07:27,029 --> 00:07:29,649
vale, nuevo procedimiento

128
00:07:29,649 --> 00:07:31,810
le damos un nombre, pues lo vamos a llamar

129
00:07:31,810 --> 00:07:33,629
test porque es un procedimiento que

130
00:07:33,629 --> 00:07:35,230
vamos a utilizar para testear código

131
00:07:35,230 --> 00:07:37,550
y ahora aquí dentro

132
00:07:37,550 --> 00:07:38,230
del begin.jl

133
00:07:38,230 --> 00:08:03,230
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.

134
00:08:03,230 --> 00:08:14,009
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.

135
00:08:14,009 --> 00:08:43,460
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í.

136
00:08:43,460 --> 00:08:45,700
vamos a darle otra vez a depurar

137
00:08:45,700 --> 00:08:50,289
a ver, ha tenido la mayúscula activada

138
00:08:50,289 --> 00:08:55,440
vale, ahora mira, se ha parado

139
00:08:55,440 --> 00:08:57,399
en el punto de ruptura, tengo aquí

140
00:08:57,399 --> 00:08:59,559
los datos de las

141
00:08:59,559 --> 00:09:00,820
de las variables

142
00:09:00,820 --> 00:09:02,960
de acuerdo

143
00:09:02,960 --> 00:09:04,759
a ver

144
00:09:04,759 --> 00:09:07,659
ahora le voy

145
00:09:07,659 --> 00:09:08,240
dando F8

146
00:09:08,240 --> 00:09:11,679
me va diciendo los valores

147
00:09:11,679 --> 00:09:13,000
que va tomando la M

148
00:09:13,000 --> 00:09:15,759
me va diciendo el valor que va tomando

149
00:09:15,759 --> 00:09:17,700
la I, fijaros

150
00:09:17,700 --> 00:09:24,580
¿Veis? Es el primero que ha recuperado, me dice que es el de ID 1111

151
00:09:24,580 --> 00:09:26,700
Estoy aquí en esta parte del ratón que veis

152
00:09:26,700 --> 00:09:30,980
Si lo de F8 se incrementa el contador

153
00:09:30,980 --> 00:09:34,240
Ahora la M vale 2

154
00:09:34,240 --> 00:09:36,759
Entonces entramos en el bucle

155
00:09:36,759 --> 00:09:39,580
Ahora ha leído nuevo, fijaros aquí, ha leído nuevo

156
00:09:39,580 --> 00:09:42,220
Uno nuevo y así sucesivamente

157
00:09:42,220 --> 00:09:46,440
Y voy dándole vueltas al bucle y viendo cómo van cambiando las variables

158
00:09:46,960 --> 00:09:54,240
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á.

159
00:09:54,899 --> 00:10:01,220
Bien, y ahora para finalizar, lo que quiero hacer es depurar un disparador, ¿de acuerdo?

160
00:10:01,899 --> 00:10:03,120
Entonces voy a cerrar esto.

161
00:10:03,500 --> 00:10:05,480
Yo tengo aquí un disparador ya preparado.

162
00:10:06,220 --> 00:10:11,539
Si no, en cualquier caso, os vais aquí a la parte izquierda de la pantalla y aquí veis los disparadores que hay.

163
00:10:11,600 --> 00:10:12,340
Yo lo voy a cerrar.

164
00:10:12,340 --> 00:10:14,279
este, quiero hacer

165
00:10:14,279 --> 00:10:16,220
el de insertar

166
00:10:16,220 --> 00:10:18,100
nuevas nacionalidades, le doy aquí al código

167
00:10:18,100 --> 00:10:20,080
bien, me aparece, este ya está

168
00:10:20,080 --> 00:10:22,139
compilado y demás, pues si no igual le daríamos aquí

169
00:10:22,139 --> 00:10:24,179
para compilar, para depuración, bien, tiene un punto

170
00:10:24,179 --> 00:10:26,159
de ruptura puesto aquí, yo el

171
00:10:26,159 --> 00:10:28,159
punto de ruptura, este de aquí lo voy a quitar

172
00:10:28,159 --> 00:10:30,120
con el F5, pongo y quito puntos

173
00:10:30,120 --> 00:10:32,100
de ruptura y aquí de nuevo

174
00:10:32,100 --> 00:10:34,139
le doy con el F5 para ponérmelo

175
00:10:34,139 --> 00:10:36,000
en el BGIT y entonces lo que voy a hacer es

176
00:10:36,000 --> 00:10:38,039
depurarlo

177
00:10:38,039 --> 00:10:39,980
vale

178
00:10:39,980 --> 00:10:42,139
entonces, importante ahora

179
00:10:42,139 --> 00:10:45,659
lo siguiente, mirad, aquí me pone los valores de entrada

180
00:10:45,659 --> 00:10:50,179
y me sale aquí la línea que se intenta insertar en la tabla

181
00:10:50,179 --> 00:10:52,539
de músicos que es lo que va a hacer que salte

182
00:10:52,539 --> 00:10:58,059
el disparador, entonces yo lo que tengo que hacer aquí es escribir los valores

183
00:10:58,059 --> 00:11:03,750
que quiero, vale, vamos a meter una nacionalidad

184
00:11:03,750 --> 00:11:09,070
y aquí, esto es la experiencia

185
00:11:09,070 --> 00:11:12,909
vamos a meter un valor numérico y por último el instrumento, subliterar

186
00:11:12,909 --> 00:11:14,950
una cadena y lo

187
00:11:14,950 --> 00:11:15,990
meto de esta

188
00:11:15,990 --> 00:11:18,970
manera, de acuerdo

189
00:11:18,970 --> 00:11:20,889
voy a cambiar la clave porque

190
00:11:20,889 --> 00:11:23,190
es una con la que he estado probando antes, no vaya a ser

191
00:11:23,190 --> 00:11:24,690
que este

192
00:11:24,690 --> 00:11:26,950
que se repita, y ahora lo que hago

193
00:11:26,950 --> 00:11:28,789
es que le doy a aceptar, o sea, importante

194
00:11:28,789 --> 00:11:30,769
cuando le he dado de pura al disparador me sale esta

195
00:11:30,769 --> 00:11:32,649
ventana y aquí, donde pone bloque

196
00:11:32,649 --> 00:11:34,909
PLSQL, aquí como lo que vamos

197
00:11:34,909 --> 00:11:36,870
a hacer es una inserción en la tabla músico, lo que yo

198
00:11:36,870 --> 00:11:38,909
puedo hacer es meter los valores

199
00:11:38,909 --> 00:11:41,009
de los cuatro campos, en este caso 1, 2, 3

200
00:11:41,009 --> 00:11:43,029
4, 5, 1, 2, 3, 4, 5

201
00:11:43,029 --> 00:11:45,090
que quiero insertar, que quiero

202
00:11:45,090 --> 00:11:47,110
probar con el disparador, entonces le doy a aceptar

203
00:11:47,110 --> 00:11:49,049
metemos la contraseña

204
00:11:49,049 --> 00:11:54,799
¿vale? y fijaros que se ha

205
00:11:54,799 --> 00:11:56,659
parado en el punto de ruptura

206
00:11:56,659 --> 00:11:58,580
que yo le he puesto, que es el begin del código

207
00:11:58,580 --> 00:12:00,799
¿vale? entonces si nos vamos por aquí

208
00:12:00,799 --> 00:12:02,860
hacemos un

209
00:12:02,860 --> 00:12:04,799
un F8, fijaros

210
00:12:04,799 --> 00:12:05,919
antes de darle al cursor

211
00:12:05,919 --> 00:12:08,000
si le damos aquí a new

212
00:12:08,000 --> 00:12:10,779
y acordaros que en un disparador

213
00:12:10,779 --> 00:12:12,779
cuando hacemos referencia con dos puntos

214
00:12:12,779 --> 00:12:14,120
new, lo que estamos indicando son

215
00:12:14,120 --> 00:12:18,860
los valores del registro que queremos insertar.

216
00:12:19,059 --> 00:12:26,000
En este caso, como no es una modificación, es de lo único que nos tenemos que preocupar.

217
00:12:26,059 --> 00:12:39,110
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,

218
00:12:39,110 --> 00:12:41,629
ejecuto esta línea y ahora

219
00:12:41,629 --> 00:12:43,830
lo que estoy guardando en total es

220
00:12:43,830 --> 00:12:46,110
el select count de las nuevas nacionalidades

221
00:12:46,110 --> 00:12:47,669
y tiene cero, quiere decir

222
00:12:47,669 --> 00:12:49,789
que la tabla nuevas nacionalidades no ha

223
00:12:49,789 --> 00:12:51,570
encontrado nada, entonces

224
00:12:51,570 --> 00:12:53,690
metemos por aquí, si total

225
00:12:53,690 --> 00:12:55,669
es cero, eso es cierto y entonces ahora

226
00:12:55,669 --> 00:12:57,210
lo que voy a hacer es insertar en la tabla

227
00:12:57,210 --> 00:12:59,649
nuevas nacionalidades, los valores

228
00:12:59,649 --> 00:13:00,889
que

229
00:13:00,889 --> 00:13:03,629
de la nueva

230
00:13:03,629 --> 00:13:05,690
nacionalidad y el número de valores

231
00:13:05,690 --> 00:13:07,509
¿de acuerdo? y de esta manera

232
00:13:07,509 --> 00:13:09,690
ejecutamos el

233
00:13:09,690 --> 00:13:10,230
disparador

234
00:13:10,230 --> 00:13:13,730
y terminamos. Y esta es la

235
00:13:13,730 --> 00:13:15,629
manera, poniendo puntos de ruptura, la

236
00:13:15,629 --> 00:13:17,490
manera que tenéis para poder

237
00:13:17,490 --> 00:13:19,549
depurar el código. Ya digo, si

238
00:13:19,549 --> 00:13:20,990
tenemos trozos de código

239
00:13:20,990 --> 00:13:23,629
que no vayan, o sea, que estén

240
00:13:23,629 --> 00:13:25,529
en un bloque principal, lo que podemos hacer es crear

241
00:13:25,529 --> 00:13:26,970
un procedimiento que se llama test,

242
00:13:27,649 --> 00:13:29,590
los metemos ahí y ahí podemos poner

243
00:13:29,590 --> 00:13:30,889
un punto de ruptura y ir probando

244
00:13:30,889 --> 00:13:33,669
el código línea a línea. Bueno, pues

245
00:13:33,669 --> 00:13:35,710
espero que esto os haya resultado de

246
00:13:35,710 --> 00:13:36,470
utilidad.

247
00:13:37,509 --> 00:13:38,509
Gracias.