1
00:00:01,199 --> 00:00:02,899
¿Qué nos falta de nuestro CRUD?

2
00:00:02,899 --> 00:00:09,259
Entonces, pues nos falta recuperar personas.

3
00:00:09,759 --> 00:00:16,370
Por ejemplo, podemos hacer recuperar por clave.

4
00:00:16,629 --> 00:00:17,210
Entonces, si recupera...

5
00:00:17,870 --> 00:00:18,530
Uy, perdón.

6
00:00:19,989 --> 00:00:22,710
Vale, pues si recuperamos por clave primaria,

7
00:00:23,190 --> 00:00:26,969
este método me va a devolver una persona.

8
00:00:27,550 --> 00:00:28,109
¿Verdad?

9
00:00:28,149 --> 00:00:29,609
Me va a devolver una única persona,

10
00:00:29,989 --> 00:00:32,369
que puede ser null si la clave primaria no existe,

11
00:00:32,369 --> 00:00:33,990
Pero en el caso de que la clave primaria exista

12
00:00:33,990 --> 00:00:34,929
Será una como mucho

13
00:00:34,929 --> 00:00:36,570
Entonces

14
00:00:36,570 --> 00:00:39,490
Pues get persona

15
00:00:39,490 --> 00:00:42,189
Y aquí que le daríamos como parámetro

16
00:00:42,189 --> 00:00:43,649
Esto de aquí

17
00:00:43,649 --> 00:00:54,340
Vale, mira los de al lado también están con personas

18
00:00:54,340 --> 00:00:55,880
Que originales somos

19
00:00:55,880 --> 00:00:56,299
Todos

20
00:00:56,299 --> 00:00:59,399
Vale, pues a ver

21
00:00:59,399 --> 00:01:01,899
Aquí la conexión hay que hacerla

22
00:01:01,899 --> 00:01:03,619
Igualmente, exactamente igual

23
00:01:03,619 --> 00:01:06,159
Entonces vamos a hacer nuestro try con la conexión

24
00:01:06,159 --> 00:01:07,799
Exactamente igual

25
00:01:07,799 --> 00:01:12,909
De hecho como le voy a copiar todo

26
00:01:12,909 --> 00:01:16,489
y ahora quito lo que me sobre, voy a copiar

27
00:01:16,489 --> 00:01:20,969
mi código del anterior y ahora vamos a eliminar

28
00:01:20,969 --> 00:01:24,069
todo lo que nos sobre, nos sobra este retun

29
00:01:24,069 --> 00:01:29,390
este retun falso, en lugar de retun falso sería retun

30
00:01:29,390 --> 00:01:34,129
null, muy bien, y aquí ya devolveremos

31
00:01:34,129 --> 00:01:38,219
lo que toque devolver, de hecho

32
00:01:38,219 --> 00:01:41,620
lo que yo voy a devolver, esta persona

33
00:01:41,620 --> 00:01:46,819
persona que es igual a nul

34
00:01:46,819 --> 00:01:48,900
se supone que la voy a

35
00:01:48,900 --> 00:01:49,200
aquí

36
00:01:49,200 --> 00:01:52,739
la voy aquí

37
00:01:52,739 --> 00:01:54,840
a instanciar, a construir como sea

38
00:01:54,840 --> 00:01:56,040
y luego la devolveré aquí

39
00:01:56,040 --> 00:02:00,500
persona, vale

40
00:02:00,500 --> 00:02:03,299
entonces la conexión la voy a necesitar igualmente

41
00:02:03,299 --> 00:02:04,379
pues la conexión se queda

42
00:02:04,379 --> 00:02:07,159
y una sentencia también la vamos a necesitar

43
00:02:07,159 --> 00:02:07,739
igualmente

44
00:02:07,739 --> 00:02:11,379
ahora el tema es esta sentencia

45
00:02:11,379 --> 00:02:12,340
que tiene que hacer

46
00:02:12,340 --> 00:02:13,560
vale

47
00:02:13,560 --> 00:02:16,479
pues ahora esta sentencia

48
00:02:16,479 --> 00:02:18,740
en lugar de llamar a un

49
00:02:18,740 --> 00:02:20,340
execute

50
00:02:20,340 --> 00:02:22,319
ubdate como en el caso anterior

51
00:02:22,319 --> 00:02:24,659
porque tanto si yo quiero hacer insert

52
00:02:24,659 --> 00:02:26,060
como aquí

53
00:02:26,060 --> 00:02:28,340
como si quiero hacer deletes

54
00:02:28,340 --> 00:02:30,620
como haré aquí, como si quiero hacer

55
00:02:30,620 --> 00:02:32,939
ubdates como haré aquí, en cualquiera de esos casos

56
00:02:32,939 --> 00:02:34,979
esta sentencia llamaría

57
00:02:34,979 --> 00:02:36,560
al execute

58
00:02:36,560 --> 00:02:37,479
ubdate

59
00:02:37,479 --> 00:02:40,659
llamaría al execute

60
00:02:40,659 --> 00:02:41,740
ubdate con lo que fuera

61
00:02:41,740 --> 00:02:45,099
pero si lo que yo quiero es hacer una consulta

62
00:02:45,099 --> 00:02:47,159
un select

63
00:02:47,159 --> 00:02:51,240
pues entonces al que tiene que llamar es al execute query

64
00:02:51,240 --> 00:02:57,909
el execute query poniendo aquí el SQL que toque

65
00:02:57,909 --> 00:03:00,009
ahora lo haremos, poniendo ahí el SQL que toque

66
00:03:00,009 --> 00:03:03,550
pero claro, este execute query

67
00:03:03,550 --> 00:03:05,969
ahora ya sí que me va a devolver cosas

68
00:03:05,969 --> 00:03:08,710
es el conjunto de registros

69
00:03:08,710 --> 00:03:10,969
en este caso será uno como mucho

70
00:03:10,969 --> 00:03:15,710
pero bueno, en principio el query me va a devolver un conjunto de registros

71
00:03:15,710 --> 00:03:19,250
que es el resultante de la select, vale, pues

72
00:03:19,250 --> 00:03:22,569
donde, en qué estructura guarda

73
00:03:22,569 --> 00:03:27,689
el estándar JDBC los resultados de una select

74
00:03:27,689 --> 00:03:31,729
pues los guarda en una estructura de datos que se llama

75
00:03:31,729 --> 00:03:41,360
result set, result set que es

76
00:03:41,360 --> 00:03:45,139
efectivamente de la API JDBC

77
00:03:45,139 --> 00:03:49,620
bueno, pues en la estructura

78
00:03:49,620 --> 00:03:51,960
result set, que es un set

79
00:03:51,960 --> 00:03:54,120
en realidad, en esta estructura

80
00:03:54,120 --> 00:03:55,860
me guarda todos los registros

81
00:03:55,860 --> 00:03:57,979
resultantes de esta

82
00:03:57,979 --> 00:03:59,159
select que yo ponga aquí

83
00:03:59,159 --> 00:04:01,419
ahora tenemos que hacer nuestra select, claro

84
00:04:01,419 --> 00:04:03,500
pues nuestra select va a ser

85
00:04:03,500 --> 00:04:06,099
select, quiero todos los

86
00:04:06,099 --> 00:04:07,099
campos, venga, sí

87
00:04:07,099 --> 00:04:09,939
porque quiero construir la persona

88
00:04:09,939 --> 00:04:11,800
enterita con todos sus campos

89
00:04:11,800 --> 00:04:14,319
devuélveme todos los campos

90
00:04:14,319 --> 00:04:16,339
from la tabla que sea

91
00:04:16,339 --> 00:04:18,120
que mi tabla se llamaba

92
00:04:18,120 --> 00:04:20,279
personas

93
00:04:20,279 --> 00:04:24,069
yo la llamé personas

94
00:04:24,069 --> 00:04:27,509
y tiene un where esto

95
00:04:27,509 --> 00:04:35,519
where

96
00:04:35,519 --> 00:04:38,379
id igual

97
00:04:38,379 --> 00:04:39,980
igual a que

98
00:04:39,980 --> 00:04:42,079
a este parámetro

99
00:04:42,079 --> 00:04:45,060
con lo cual voy a tener que romper este de aquí

100
00:04:45,060 --> 00:04:46,480
y

101
00:04:46,480 --> 00:04:47,920
concatenarlo

102
00:04:47,920 --> 00:04:49,439
con esto

103
00:04:49,439 --> 00:04:55,980
entonces este select

104
00:04:55,980 --> 00:04:58,939
ahora ya será selet asterisco from personas

105
00:04:58,939 --> 00:05:00,160
query de igual

106
00:05:00,160 --> 00:05:02,240
y después va a venir esto

107
00:05:02,240 --> 00:05:04,259
3, 7, 15, lo que sea

108
00:05:04,259 --> 00:05:10,560
vale

109
00:05:10,560 --> 00:05:14,040
ahora yo ya

110
00:05:14,040 --> 00:05:16,939
una vez que se ha ejecutado el query

111
00:05:16,939 --> 00:05:19,420
tengo aquí un montón de registros con el resultado

112
00:05:19,420 --> 00:05:21,139
como itero

113
00:05:21,139 --> 00:05:22,600
por el result set

114
00:05:22,600 --> 00:05:24,740
no itero como una colección normal y corriente

115
00:05:24,740 --> 00:05:27,000
como nuestro set con un for each y con nada de eso

116
00:05:27,000 --> 00:05:29,079
porque lo que tiene cada registro

117
00:05:29,079 --> 00:05:31,040
dentro a su vez son un montón de campos

118
00:05:31,040 --> 00:05:33,360
entonces no

119
00:05:33,360 --> 00:05:35,399
itero de una manera propia

120
00:05:35,399 --> 00:05:37,399
suya, entonces registros

121
00:05:37,399 --> 00:05:38,160
tiene un método

122
00:05:38,160 --> 00:05:40,399
que es el método

123
00:05:40,399 --> 00:05:42,540
vale

124
00:05:42,540 --> 00:05:48,740
next, el método

125
00:05:48,740 --> 00:05:49,480
next

126
00:05:49,480 --> 00:05:52,220
te dice si

127
00:05:52,220 --> 00:05:52,899
a ver

128
00:05:52,899 --> 00:05:56,579
el result set

129
00:05:56,579 --> 00:05:59,160
internamente

130
00:05:59,160 --> 00:06:01,199
este result set de aquí internamente

131
00:06:01,199 --> 00:06:03,040
es como

132
00:06:03,040 --> 00:06:03,759
una tablita

133
00:06:03,759 --> 00:06:06,540
con los registros y cada registro

134
00:06:06,540 --> 00:06:07,480
con su campo, ¿verdad?

135
00:06:08,100 --> 00:06:10,639
id, nombre, edad, id, nombre, edad

136
00:06:10,639 --> 00:06:12,279
vale, pues la estructura result set

137
00:06:12,279 --> 00:06:13,779
inicialmente

138
00:06:13,779 --> 00:06:16,560
se queda apuntando

139
00:06:16,560 --> 00:06:18,000
o se queda posicionada

140
00:06:18,000 --> 00:06:20,300
se queda posicionada en la anterior

141
00:06:20,300 --> 00:06:20,939
a la primera

142
00:06:20,939 --> 00:06:23,980
cada vez que hagamos un next

143
00:06:23,980 --> 00:06:25,740
cada vez que hagamos un next

144
00:06:25,740 --> 00:06:28,040
avanza una posición

145
00:06:28,040 --> 00:06:30,360
entonces yo tengo que hacer un primer next

146
00:06:30,360 --> 00:06:31,899
sí o sí, para quedarme en la primera

147
00:06:31,899 --> 00:06:34,560
entonces este next además de avanzar

148
00:06:34,560 --> 00:06:36,699
una posición en mi lista de registros

149
00:06:36,699 --> 00:06:38,860
me devuelve true o false

150
00:06:38,860 --> 00:06:40,100
si realmente

151
00:06:40,100 --> 00:06:42,220
hay un registro en el que posicionarse

152
00:06:42,220 --> 00:06:44,060
es decir

153
00:06:44,060 --> 00:06:46,540
si yo aquí en mis registros next

154
00:06:46,540 --> 00:06:48,360
me diera false desde el principio

155
00:06:48,360 --> 00:06:49,579
es que

156
00:06:49,579 --> 00:06:52,379
no ha habido resultado

157
00:06:52,379 --> 00:06:54,100
en esta consulta

158
00:06:54,100 --> 00:06:56,360
no ha habido resultado, con lo cual el primer next

159
00:06:56,360 --> 00:06:58,579
ya me sale false, porque no hay ni un primero

160
00:06:58,579 --> 00:07:00,339
en el que posicionarse, no hay ni un primero

161
00:07:00,339 --> 00:07:01,680
¿vale?

162
00:07:01,899 --> 00:07:04,540
entonces yo puedo jugar con ese hecho

163
00:07:04,540 --> 00:07:07,079
con el hecho de que el next se posiciona

164
00:07:07,079 --> 00:07:08,240
y además se devuelve true

165
00:07:08,240 --> 00:07:10,920
si se posiciona en un sitio correcto

166
00:07:10,920 --> 00:07:11,819
porque todavía hay

167
00:07:11,819 --> 00:07:13,560
metiéndolo en un while

168
00:07:13,560 --> 00:07:19,139
y esto funcionaría así

169
00:07:19,139 --> 00:07:23,209
entonces jugaríamos con esto

170
00:07:23,209 --> 00:07:24,269
metiéndolo en un while

171
00:07:24,269 --> 00:07:26,329
entonces este while

172
00:07:26,329 --> 00:07:28,470
¿qué iría haciendo? pues este while

173
00:07:28,470 --> 00:07:30,209
en cada iteración

174
00:07:30,209 --> 00:07:33,610
va colocándose en cada uno de los registros

175
00:07:33,610 --> 00:07:35,990
¿verdad?

176
00:07:36,189 --> 00:07:37,649
si estos son mis registros

177
00:07:37,649 --> 00:07:40,149
en la primera vuelta del while

178
00:07:40,149 --> 00:07:41,470
se ha colocado aquí

179
00:07:41,470 --> 00:07:43,370
y yo ahora aquí hago lo que sea

180
00:07:43,370 --> 00:07:45,970
en la siguiente vuelta del while

181
00:07:45,970 --> 00:07:48,189
se ha colocado aquí y ahora ya hago lo que sea

182
00:07:48,189 --> 00:07:50,470
en la siguiente vuelta del while

183
00:07:50,470 --> 00:07:52,550
se ha colocado aquí y ahora ya hago lo que sea

184
00:07:52,550 --> 00:07:54,290
así hasta que haya

185
00:07:54,290 --> 00:07:55,389
una vuelta del while

186
00:07:55,389 --> 00:07:57,529
que ya me ha dado false

187
00:07:57,529 --> 00:08:00,069
porque no hay nada en donde colocarse

188
00:08:00,069 --> 00:08:02,730
me ha dado false con lo cual este while terminaría

189
00:08:02,730 --> 00:08:02,970
¿vale?

190
00:08:03,610 --> 00:08:11,449
Luego este while, tal y como está puesto, solamente con esta condición aquí por ahora, va haciendo esto, va avanzando.

191
00:08:11,569 --> 00:08:14,730
Primer registro, segundo registro, tercer registro, cuarto registro.

192
00:08:14,870 --> 00:08:16,730
El while termina cuando ya no hay más registro.

193
00:08:17,949 --> 00:08:22,050
Ahora nos queda la siguiente parte, que es, vale, una vez que ya está posicionado en cada registro,

194
00:08:22,930 --> 00:08:24,550
¿cómo saca de él la información?

195
00:08:24,730 --> 00:08:26,389
Porque es lo que queremos hacer, sacar la información.

196
00:08:27,589 --> 00:08:32,690
Bueno, pues este result set tiene métodos para sacar los datos.

197
00:08:35,759 --> 00:08:46,039
No, porque es un select asterisco.

198
00:08:46,799 --> 00:08:48,159
O sea, me devuelve todos los campos.

199
00:08:54,500 --> 00:08:56,519
Ah, este en particular

200
00:08:56,519 --> 00:08:58,399
me va a dar o una

201
00:08:58,399 --> 00:09:00,720
o ninguna, porque el ID podría no existir.

202
00:09:01,159 --> 00:09:02,259
En este caso en particular.

203
00:09:02,620 --> 00:09:04,360
Pero bueno, yo esa explicación la he dado en general.

204
00:09:04,879 --> 00:09:06,460
Si fuera un select que te devolviera

205
00:09:06,460 --> 00:09:08,360
más. ¿Vale? En nuestro

206
00:09:08,360 --> 00:09:10,320
caso en particular este while o no

207
00:09:10,320 --> 00:09:12,440
se ejecuta nunca porque directamente

208
00:09:12,440 --> 00:09:14,399
el id no existe, luego

209
00:09:14,399 --> 00:09:16,120
es vacío, no hay nada

210
00:09:16,120 --> 00:09:18,500
por donde ir, o si realmente

211
00:09:18,500 --> 00:09:20,200
existe este id, este while

212
00:09:20,200 --> 00:09:22,340
va a entrar solo una vez, efectivamente, va a entrar

213
00:09:22,340 --> 00:09:23,860
solo una vez, ¿vale?

214
00:09:24,340 --> 00:09:25,840
Pero nosotros a priori

215
00:09:25,840 --> 00:09:28,460
en una sentencia de select genérica

216
00:09:28,460 --> 00:09:30,539
no sabemos cuántos registros

217
00:09:30,539 --> 00:09:32,480
va a haber, por eso siempre usamos

218
00:09:32,480 --> 00:09:34,379
esta estructura, que solo

219
00:09:34,379 --> 00:09:36,399
se ejecuta una vez, vale, pues solo

220
00:09:36,399 --> 00:09:40,580
se ha ejecutado una vez. ¿Que no se ha ejecutado ninguna? Pues no se ha ejecutado ninguna

221
00:09:40,580 --> 00:09:43,879
porque no hay registros. Entonces, ahora

222
00:09:43,879 --> 00:09:48,399
en cada iteración que estamos posicionados, en cada registro

223
00:09:48,399 --> 00:09:51,840
¿cómo sacamos los datos? Pues mi estructura registros

224
00:09:51,840 --> 00:09:56,080
tiene unos métodos que son get para sacar los valores de los campos

225
00:09:56,080 --> 00:10:00,019
por ejemplo, yo aquí que quiero el campo nombre de ese registro

226
00:10:00,019 --> 00:10:04,600
el campo nombre sé que es un barchar, un string, pues lo saco así

227
00:10:04,600 --> 00:10:07,639
este sería el campo nombre

228
00:10:07,639 --> 00:10:10,700
entonces yo aquí podría hacer

229
00:10:10,700 --> 00:10:12,860
este campo nombre a quien se lo quiero poner

230
00:10:12,860 --> 00:10:15,799
al set de la persona

231
00:10:15,799 --> 00:10:17,519
entonces vamos a

232
00:10:17,519 --> 00:10:19,659
entrar aquí

233
00:10:19,659 --> 00:10:23,639
vamos a crearnos nuestra persona p

234
00:10:23,639 --> 00:10:25,559
igual a

235
00:10:25,559 --> 00:10:39,100
p igual a new persona

236
00:10:39,100 --> 00:10:40,179
vale

237
00:10:40,179 --> 00:10:42,639
y ahora el constructor

238
00:10:42,639 --> 00:10:44,919
sin parámetros lo quité cuando puse

239
00:10:44,919 --> 00:10:45,340
el otro

240
00:10:45,340 --> 00:10:47,580
entonces

241
00:10:47,580 --> 00:10:50,799
bueno, ni siquiera hace falta

242
00:10:50,799 --> 00:10:52,379
por pura vaguería

243
00:10:52,379 --> 00:10:56,450
registros para hacerlo

244
00:10:56,450 --> 00:10:57,870
por partes, este sería

245
00:10:57,870 --> 00:10:59,389
el nombre

246
00:10:59,389 --> 00:11:01,549
de ese registro

247
00:11:01,549 --> 00:11:04,450
¿verdad? el campo nombre de ese registro

248
00:11:04,450 --> 00:11:05,649
vámonos por el campo id

249
00:11:05,649 --> 00:11:08,049
el campo id

250
00:11:08,049 --> 00:11:12,840
perdón

251
00:11:12,840 --> 00:11:14,259
el campo id no, el campo edad

252
00:11:14,259 --> 00:11:16,659
el campo id ya lo tengo, es por el que he buscado

253
00:11:16,659 --> 00:11:19,340
el campo edad

254
00:11:19,340 --> 00:11:20,440
sería get

255
00:11:20,440 --> 00:11:21,740
como es un ínteger

256
00:11:21,740 --> 00:11:23,059
pues será get in

257
00:11:23,059 --> 00:11:25,740
get in edad

258
00:11:25,740 --> 00:11:28,740
y ahora me voy a construir

259
00:11:28,740 --> 00:11:30,179
una persona con esos valores

260
00:11:30,179 --> 00:11:31,500
y la devuelvo con valor de retorno

261
00:11:31,500 --> 00:11:33,500
y ahora ya

262
00:11:33,500 --> 00:11:35,720
mi persona p

263
00:11:35,720 --> 00:11:36,580
igual

264
00:11:36,580 --> 00:11:39,820
construyo una persona

265
00:11:39,820 --> 00:11:40,980
new persona

266
00:11:40,980 --> 00:11:42,799
con

267
00:11:42,799 --> 00:11:47,950
voy a hacer un

268
00:11:47,950 --> 00:11:49,629
constructor con el id también

269
00:11:49,629 --> 00:11:57,450
me construyo una persona con los

270
00:11:57,450 --> 00:11:59,570
tres parámetros y es la que voy a devolver

271
00:11:59,570 --> 00:12:02,149
new persona

272
00:12:02,149 --> 00:12:03,610
el parámetro

273
00:12:03,610 --> 00:12:03,990
id

274
00:12:03,990 --> 00:12:10,610
No, instanciada no

275
00:12:10,610 --> 00:12:11,409
La tengo a null

276
00:12:11,409 --> 00:12:13,990
Para que si nunca entro aquí me devuelva el null

277
00:12:13,990 --> 00:12:14,809
Directamente

278
00:12:14,809 --> 00:12:18,350
Edad y n

279
00:12:18,350 --> 00:12:22,220
Venga, voy a poner nombre

280
00:12:22,220 --> 00:12:24,000
Y así queda más bonito

281
00:12:24,000 --> 00:12:29,100
Vale, y esta es

282
00:12:29,100 --> 00:12:31,000
Penopersona

283
00:12:31,000 --> 00:12:37,740
Vale, pues con este while

284
00:12:37,740 --> 00:12:39,639
He avanzado al primer registro

285
00:12:39,639 --> 00:12:42,000
En mi caso el único

286
00:12:42,000 --> 00:12:44,899
de ese primer registro he sacado

287
00:12:44,899 --> 00:12:47,320
el campo nombre y el campo edad

288
00:12:47,320 --> 00:12:49,200
y me he construido la persona

289
00:12:49,200 --> 00:12:50,139
con esos tres valores

290
00:12:50,139 --> 00:12:53,379
con el valor id que es por el que yo estaba buscando

291
00:12:53,379 --> 00:12:55,679
con la edad que me ha devuelto

292
00:12:55,679 --> 00:12:57,360
la select y con el nombre que ha devuelto

293
00:12:57,360 --> 00:12:57,799
la select

294
00:12:57,799 --> 00:13:00,120
que la id no existe

295
00:13:00,120 --> 00:13:02,679
este while nunca se habría ejecutado

296
00:13:02,679 --> 00:13:05,080
entonces si la id no existe este while nunca se habría

297
00:13:05,080 --> 00:13:07,240
ejecutado con lo cual persona seguiría siendo null

298
00:13:07,240 --> 00:13:09,179
porque ese while nunca

299
00:13:09,179 --> 00:13:10,100
se habría ejecutado

300
00:13:10,100 --> 00:13:13,940
Y ahora ya lo único que me falta a mí es devolver esa persona

301
00:13:13,940 --> 00:13:15,259
Que puede ser null

302
00:13:15,259 --> 00:13:17,559
Puede ser null si el id no existe

303
00:13:17,559 --> 00:13:19,019
Porque entonces nunca entré aquí

304
00:13:19,019 --> 00:13:21,919
O si el id sí existe

305
00:13:21,919 --> 00:13:23,080
No será null

306
00:13:23,080 --> 00:13:24,700
Será la persona que sea

307
00:13:24,700 --> 00:13:27,559
¿Vale?

308
00:13:29,460 --> 00:13:30,100
Entonces

309
00:13:30,100 --> 00:13:31,940
Vamos a

310
00:13:31,940 --> 00:13:34,279
En nuestro main

311
00:13:34,279 --> 00:13:35,879
Añadir

312
00:13:35,879 --> 00:13:39,460
La funcionalidad de

313
00:13:39,460 --> 00:13:45,480
recuperar

314
00:13:45,480 --> 00:13:46,080
persona

315
00:13:46,080 --> 00:13:48,840
recuperar

316
00:13:48,840 --> 00:13:50,659
persona

317
00:13:50,659 --> 00:13:53,179
vale, sería mi caso

318
00:13:53,179 --> 00:14:06,940
dos, dirá pues

319
00:14:06,940 --> 00:14:07,419
dame el id

320
00:14:07,419 --> 00:14:10,889
dame el id

321
00:14:10,889 --> 00:14:13,730
dame el id

322
00:14:13,730 --> 00:14:16,009
pues venga, el id

323
00:14:16,009 --> 00:14:19,909
lo leo

324
00:14:19,909 --> 00:14:22,370
integer

325
00:14:22,370 --> 00:14:24,190
punto parse

326
00:14:24,190 --> 00:14:25,009
int

327
00:14:25,009 --> 00:14:29,309
de scan.nextline

328
00:14:29,309 --> 00:14:34,409
no lo leo con next in para evitar todo el rollo del salto de línea

329
00:14:34,409 --> 00:14:38,230
del buffer, etcétera, y ahora ya puedo llamar a

330
00:14:38,230 --> 00:14:39,929
operaciones

331
00:14:39,929 --> 00:14:42,649
operaciones.

332
00:14:42,649 --> 00:14:42,990
operaciones.

333
00:14:46,830 --> 00:14:48,830
no lo hice estático

334
00:14:48,830 --> 00:14:52,429
o algo, a ver, operaciones

335
00:14:52,429 --> 00:14:54,350
¿dónde está? gestión persona es este

336
00:14:54,350 --> 00:14:56,210
no, no lo tengo

337
00:14:56,210 --> 00:14:56,870
ah, está aquí

338
00:14:56,870 --> 00:15:00,250
exacto, no lo hice static

339
00:15:00,250 --> 00:15:04,200
vale, no lo hice static

340
00:15:04,200 --> 00:15:06,080
ahora ya

341
00:15:06,080 --> 00:15:10,840
ah, main aquí

342
00:15:10,840 --> 00:15:15,039
operaciones.getpersona

343
00:15:15,039 --> 00:15:15,279
id

344
00:15:15,279 --> 00:15:18,000
esta me va a devolver una persona

345
00:15:18,000 --> 00:15:19,059
me va a devolver una persona

346
00:15:19,059 --> 00:15:21,379
venga, vamos a mostrarla directamente

347
00:15:21,379 --> 00:15:37,549
Tú esto ya luego lo dejas bonito

348
00:15:37,549 --> 00:15:40,330
Si es null puedes poner

349
00:15:40,330 --> 00:15:41,330
No existe la persona

350
00:15:41,330 --> 00:15:43,330
Vamos a ponerlo bonito

351
00:15:43,330 --> 00:15:45,370
Si

352
00:15:45,370 --> 00:15:50,350
Si persona

353
00:15:50,350 --> 00:15:50,970
P

354
00:15:50,970 --> 00:15:53,649
Siendo persona P igual a

355
00:15:53,649 --> 00:15:57,850
operaciones.getPersonaId

356
00:15:57,850 --> 00:16:00,789
si esta persona p

357
00:16:00,789 --> 00:16:04,250
resulta que es diferente de null

358
00:16:04,250 --> 00:16:10,870
resulta que es diferente de null

359
00:16:10,870 --> 00:16:16,500
entonces, ahora lo reviso

360
00:16:16,500 --> 00:16:23,000
me falta aquí un paréntesis

361
00:16:23,000 --> 00:16:24,440
vale

362
00:16:33,789 --> 00:16:46,429
Persona es diferente de nul

363
00:16:46,429 --> 00:16:48,769
Entonces si sop

364
00:16:48,769 --> 00:16:50,450
Ahora tendré que hacer el toString

365
00:16:50,450 --> 00:16:52,850
Y si no

366
00:16:52,850 --> 00:16:53,990
Ahora arreglamos eso

367
00:16:53,990 --> 00:16:56,590
Y si no pues mostramos

368
00:16:56,590 --> 00:17:01,269
No existe nadie

369
00:17:01,269 --> 00:17:03,490
Con ese id

370
00:17:03,490 --> 00:17:05,390
Vale

371
00:17:05,390 --> 00:17:06,710
Y ahora

372
00:17:06,710 --> 00:17:08,670
Esto de aquí

373
00:17:08,670 --> 00:17:10,690
este cierra este

374
00:17:10,690 --> 00:17:12,509
es diferente de nul

375
00:17:12,509 --> 00:17:19,559
pues me gustaría poder

376
00:17:19,559 --> 00:17:21,579
pero si no me va a dejar

377
00:17:21,579 --> 00:17:23,880
tendré que declararlo

378
00:17:23,880 --> 00:17:24,319
fuera

379
00:17:24,319 --> 00:17:29,910
no me digas que no, es que como en el for

380
00:17:29,910 --> 00:17:32,089
tenemos la costumbre de quedarlo siempre dentro

381
00:17:32,089 --> 00:17:39,910
no me deja declararlo

382
00:17:39,910 --> 00:17:40,809
que pena

383
00:17:40,809 --> 00:17:50,960
persona p

384
00:17:50,960 --> 00:17:52,859
igual a nul

385
00:17:52,859 --> 00:17:56,400
vale

386
00:17:56,400 --> 00:17:59,160
Pues si p es diferente de null

387
00:17:59,160 --> 00:18:00,279
Muéstrame la persona

388
00:18:00,279 --> 00:18:02,279
Y si no, no existe nadie con ese id

389
00:18:02,279 --> 00:18:04,740
Y ahora hombre, para que esto quede bonito

390
00:18:04,740 --> 00:18:05,980
Vamos a poner un toString en persona

391
00:18:05,980 --> 00:18:10,619
Vamos a poner aquí un toString

392
00:18:10,619 --> 00:18:14,700
Generate toString

393
00:18:14,700 --> 00:18:16,000
Con los tres valores

394
00:18:16,000 --> 00:18:17,220
Y ya está

395
00:18:17,220 --> 00:18:29,049
Vale, pues este es mi main

396
00:18:29,049 --> 00:18:32,859
Vamos a probarlo

397
00:18:32,859 --> 00:18:45,900
A ver si existe la persona con el id 1

398
00:18:45,900 --> 00:18:47,500
Si que existe

399
00:18:47,500 --> 00:18:49,660
Pero la persona con el id 78

400
00:18:49,660 --> 00:18:51,240
78 pues no existe

401
00:18:51,240 --> 00:18:56,910
vale, pues este es el CRUD

402
00:18:56,910 --> 00:18:58,390
básico, basiquísimo

403
00:18:58,390 --> 00:19:00,369
lo más básico del mundo

404
00:19:00,369 --> 00:19:03,089
y sin ningún patrón de diseño, ni dado ni nada

405
00:19:03,089 --> 00:19:04,789
para ver el funcionamiento

406
00:19:04,789 --> 00:19:06,289
ahora

407
00:19:06,289 --> 00:19:09,210
a partir de aquí es sobre todo cuestiones de diseño

408
00:19:09,210 --> 00:19:10,470
vale, bueno

409
00:19:10,470 --> 00:19:14,259
pero bueno, seguimos

410
00:19:14,259 --> 00:19:17,039
ayer ya mencionamos

411
00:19:17,039 --> 00:19:18,740
lo feo

412
00:19:18,740 --> 00:19:19,539
que es esto, verdad

413
00:19:19,539 --> 00:19:22,720
esto de romper, esto de aquí

414
00:19:22,720 --> 00:19:24,299
lo horrible que es, ¿por qué?

415
00:19:24,779 --> 00:19:28,180
porque el usuario puede meterte en este campo id

416
00:19:28,180 --> 00:19:29,500
cualquier cosa

417
00:19:29,500 --> 00:19:31,680
puede meterte cualquier cosa

418
00:19:31,680 --> 00:19:33,640
entre ellas un propio script SQL

419
00:19:33,640 --> 00:19:35,980
¿y qué te hace este de aquí?

420
00:19:36,539 --> 00:19:37,000
pues va

421
00:19:37,000 --> 00:19:38,599
y te lo coge

422
00:19:38,599 --> 00:19:41,039
entonces imaginaos que aquí construimos

423
00:19:41,039 --> 00:19:43,579
vamos a pensar que podríamos construir aquí

424
00:19:43,579 --> 00:19:45,660
para alterar este SQL

425
00:19:45,660 --> 00:19:47,960
que se convierta en otro pero válido también

426
00:19:47,960 --> 00:19:49,599
por ejemplo

427
00:19:49,599 --> 00:19:51,900
si yo le meto ahí

428
00:19:51,900 --> 00:19:55,500
un número cualquiera

429
00:19:55,500 --> 00:19:58,180
el que me dé la gana, 38

430
00:19:58,180 --> 00:19:59,579
y luego le pongo

431
00:19:59,579 --> 00:20:06,759
1 igual a 1

432
00:20:06,759 --> 00:20:08,140
¿esto es con doble igual en SQL?

433
00:20:09,400 --> 00:20:10,319
con solo 1

434
00:20:10,319 --> 00:20:12,839
esto va a ser un true

435
00:20:12,839 --> 00:20:15,099
con lo cual me va a devolver toda la base de datos entera

436
00:20:15,099 --> 00:20:15,720
toda la tabla

437
00:20:15,720 --> 00:20:24,339
claro

438
00:20:24,339 --> 00:20:30,660
Entonces esto va a ser un true

439
00:20:30,660 --> 00:20:32,960
Con lo cual da igual

440
00:20:32,960 --> 00:20:35,380
Yo puedo no tener ni idea de los ids que hay

441
00:20:35,380 --> 00:20:37,700
Pero cualquier número que ponga

442
00:20:37,700 --> 00:20:39,099
Me va a mostrar todo el contenido

443
00:20:39,099 --> 00:20:46,339
Si, o sea, puedes hacer cualquier cosa

444
00:20:46,339 --> 00:20:48,299
Pero vamos a probar esta opción la más sencilla

445
00:20:48,299 --> 00:20:50,779
Por ejemplo, yo estoy con esto aquí

446
00:20:50,779 --> 00:20:56,359
Y bueno, aquí lo único es que

447
00:20:56,359 --> 00:20:58,660
Me select asterisco

448
00:20:58,660 --> 00:21:01,880
Aquí lo único es que

449
00:21:01,880 --> 00:21:03,980
estaría pisando una persona tras otra

450
00:21:03,980 --> 00:21:05,619
vale, me mostraría la última

451
00:21:05,619 --> 00:21:08,039
claro, entonces

452
00:21:08,039 --> 00:21:13,859
vamos a hacerlo para que me

453
00:21:13,859 --> 00:21:14,700
devuelva

454
00:21:14,700 --> 00:21:18,140
una colección

455
00:21:18,140 --> 00:21:19,900
y así me devuelva

456
00:21:19,900 --> 00:21:23,119
las datos enteras, bueno

457
00:21:23,119 --> 00:21:24,880
solamente para ver cómo funciona la inyección

458
00:21:24,880 --> 00:21:27,220
vamos a dejarlo así, pero vamos a poner aquí

459
00:21:27,220 --> 00:21:31,730
un siso

460
00:21:31,730 --> 00:21:33,210
que me vaya mostrando

461
00:21:33,210 --> 00:21:35,470
las personas por las que va pasando

462
00:21:35,470 --> 00:21:38,269
entonces

463
00:21:38,269 --> 00:21:43,869
vamos a hacer que nos muestre así

464
00:21:43,869 --> 00:21:48,109
suprimir, esto va a ser

465
00:21:48,109 --> 00:21:51,750
para ver el problema de inyección, este SISO de aquí

466
00:21:51,750 --> 00:21:56,069
para ver el problema de

467
00:21:56,069 --> 00:22:00,509
inyección SQL

468
00:22:00,509 --> 00:22:03,809
vamos a añadir aquí un SISO

469
00:22:03,809 --> 00:22:06,210
Que me muestre

470
00:22:06,210 --> 00:22:08,970
Nombre

471
00:22:08,970 --> 00:22:15,920
Y edad

472
00:22:15,920 --> 00:22:18,339
Vale, entonces luego además

473
00:22:18,339 --> 00:22:19,440
Me irá construyendo

474
00:22:19,440 --> 00:22:22,039
Una persona cada vez

475
00:22:22,039 --> 00:22:24,019
Y me devolverá la última

476
00:22:24,019 --> 00:22:26,220
La que me devolverá luego es la última

477
00:22:26,220 --> 00:22:27,019
Que ha construido

478
00:22:27,019 --> 00:22:30,140
Porque una se va pisando con todas

479
00:22:30,140 --> 00:22:31,900
Vale, entonces

480
00:22:31,900 --> 00:22:34,160
Aquí

481
00:22:34,160 --> 00:22:36,839
Si yo ahora

482
00:22:36,839 --> 00:22:42,339
Espera, vamos a comprobar aquí

483
00:22:42,339 --> 00:22:45,380
Se le hace una comprueba a personas

484
00:22:45,380 --> 00:22:46,279
Vamos a ver

485
00:22:46,279 --> 00:22:49,240
Que esa sentencia está bien

486
00:22:49,240 --> 00:22:51,619
Where id

487
00:22:51,619 --> 00:22:53,279
Igual a 1

488
00:22:53,279 --> 00:22:55,000
Esta es la que yo quiero construir

489
00:22:55,000 --> 00:22:56,940
Or 1 igual a 1

490
00:22:56,940 --> 00:23:01,539
¿Vale? Esta sentencia me devolvería

491
00:23:01,539 --> 00:23:02,220
Todos, ¿verdad?

492
00:23:02,539 --> 00:23:04,700
¿Es correcto SQL?

493
00:23:05,160 --> 00:23:06,640
Vamos a comprobarlo

494
00:23:06,640 --> 00:23:07,980
Efectivamente me los devuelve todos

495
00:23:07,980 --> 00:23:11,539
Si yo le quito el or1 igual a 1

496
00:23:11,539 --> 00:23:15,200
Si yo lo quito solo me va a devolver

497
00:23:15,200 --> 00:23:16,680
El primero

498
00:23:16,680 --> 00:23:18,920
Pero si yo aquí le pongo

499
00:23:18,920 --> 00:23:21,220
Or1

500
00:23:21,220 --> 00:23:22,759
Igual a 1

501
00:23:22,759 --> 00:23:25,160
Me devuelve todos

502
00:23:25,160 --> 00:23:27,460
Con lo cual la idea es meterle este id

503
00:23:27,460 --> 00:23:29,279
Ah vale vale vale

504
00:23:29,279 --> 00:23:31,799
Pero aquí en esta selet en particular

505
00:23:31,799 --> 00:23:32,880
No podría hacer

506
00:23:32,880 --> 00:23:34,700
Inyecciones SQL

507
00:23:34,700 --> 00:23:36,720
Porque esto

508
00:23:36,720 --> 00:23:38,480
es un int

509
00:23:38,480 --> 00:23:40,319
vale, id es un int

510
00:23:40,319 --> 00:23:42,380
entonces esto no le valdría como int

511
00:23:42,380 --> 00:23:45,000
pero si el parámetro de entrada fuera string

512
00:23:45,000 --> 00:23:47,079
vale, o sea si la clave

513
00:23:47,079 --> 00:23:47,819
fuera string

514
00:23:47,819 --> 00:23:50,619
por ejemplo, vamos a recuperar

515
00:23:50,619 --> 00:23:52,920
vamos a hacer, y así vamos a recuperar

516
00:23:52,920 --> 00:23:55,099
por nombre, vale, vamos a recuperar por nombre

517
00:23:55,099 --> 00:23:57,039
y así

518
00:23:57,039 --> 00:23:58,519
y así ya atacamos el siguiente problema

519
00:23:58,519 --> 00:24:03,359
que, pero salir, ya ha salido

520
00:24:03,359 --> 00:24:05,119
vale, pues vamos a hacer

521
00:24:05,119 --> 00:24:07,420
esto lo quitamos

522
00:24:07,420 --> 00:24:11,680
Y vamos a hacer el

523
00:24:11,680 --> 00:24:14,099
Recuperar todas las personas

524
00:24:14,099 --> 00:24:15,420
Que se llamen no sé qué

525
00:24:15,420 --> 00:24:17,220
Pues venga

526
00:24:17,220 --> 00:24:20,380
Ahora, este método

527
00:24:20,380 --> 00:24:21,759
Es interesante

528
00:24:21,759 --> 00:24:23,480
Porque este ahora ya me devuelve

529
00:24:23,480 --> 00:24:24,839
Todo esto

530
00:24:24,839 --> 00:24:26,779
Todo esto me tiene que devolver

531
00:24:26,779 --> 00:24:28,900
Porque esto ya no es por clave primaria

532
00:24:28,900 --> 00:24:30,900
Entonces

533
00:24:30,900 --> 00:24:32,740
Get

534
00:24:32,740 --> 00:24:34,819
Personas

535
00:24:34,819 --> 00:24:36,359
By nombre

536
00:24:36,359 --> 00:24:50,750
Vale, pues este

537
00:24:50,750 --> 00:24:53,450
Ahora ya me tiene que devolver

538
00:24:53,450 --> 00:24:55,869
Toda una lista

539
00:24:55,869 --> 00:24:57,750
Pues venga

540
00:24:57,750 --> 00:25:00,170
Esta es la lista que me va a devolver

541
00:25:00,170 --> 00:25:01,490
Lista

542
00:25:01,490 --> 00:25:03,630
Persona, personas

543
00:25:03,630 --> 00:25:05,390
Igual a new

544
00:25:05,390 --> 00:25:07,170
Pues ArrayList, por ejemplo

545
00:25:07,170 --> 00:25:20,640
El código sería el mismo que el de arriba

546
00:25:20,640 --> 00:25:22,099
Lo que pasa es que aquí

547
00:25:22,099 --> 00:25:23,640
Cada persona construida

548
00:25:23,640 --> 00:25:25,799
Cada persona construida la añado a la colección

549
00:25:25,799 --> 00:25:27,579
¿Vale?

550
00:25:27,619 --> 00:25:29,299
Pero el código sería el mismo que el de arriba

551
00:25:29,299 --> 00:25:30,640
Entonces vamos a copiar

552
00:25:30,640 --> 00:25:33,440
todo el código que tenemos aquí arriba

553
00:25:33,440 --> 00:25:40,900
todo este código

554
00:25:40,900 --> 00:25:45,680
nuestra select cambia

555
00:25:45,680 --> 00:25:46,900
where nombre

556
00:25:46,900 --> 00:25:50,849
igual a

557
00:25:50,849 --> 00:25:53,970
como el nombre es un string

558
00:25:53,970 --> 00:25:55,710
aquí te voy a poner una comilla simple

559
00:25:55,710 --> 00:25:59,410
aquí concateno con nombre

560
00:25:59,410 --> 00:26:03,829
aquí concateno otra vez con la comilla simple de cierre

561
00:26:03,829 --> 00:26:10,869
luego la select me cambia

562
00:26:10,869 --> 00:26:12,250
eso es lo primero que me cambia

563
00:26:12,250 --> 00:26:14,890
devuélveme todos los campos de la tabla personas

564
00:26:14,890 --> 00:26:16,970
donde nombre sea igual a comilla

565
00:26:16,970 --> 00:26:19,190
el parámetro nombre que me han pasado

566
00:26:19,190 --> 00:26:20,329
cerrando con comilla

567
00:26:20,329 --> 00:26:21,690
vale

568
00:26:21,690 --> 00:26:25,470
ahora este bucle, ahora ya sí que se va a ejecutar

569
00:26:25,470 --> 00:26:26,369
un montón de veces

570
00:26:26,369 --> 00:26:29,210
vale, pues vamos a

571
00:26:29,210 --> 00:26:30,430
recuperar

572
00:26:30,430 --> 00:26:32,910
todos los campos

573
00:26:32,910 --> 00:26:34,890
el id

574
00:26:34,890 --> 00:26:39,930
registros

575
00:26:39,930 --> 00:26:41,710
punto get int

576
00:26:41,710 --> 00:26:43,750
id

577
00:26:43,750 --> 00:26:49,980
nombre

578
00:26:49,980 --> 00:26:54,170
nom

579
00:26:54,170 --> 00:26:55,849
Porque está repetido

580
00:26:55,849 --> 00:26:59,700
Bueno

581
00:26:59,700 --> 00:27:02,319
Vale, y ahora ya

582
00:27:02,319 --> 00:27:05,299
Me hago una nueva persona

583
00:27:05,299 --> 00:27:07,539
Con esos datos

584
00:27:07,539 --> 00:27:08,779
Y se la añado a la lista

585
00:27:08,779 --> 00:27:12,720
Personas.app

586
00:27:12,720 --> 00:27:13,880
Esta persona

587
00:27:13,880 --> 00:27:22,779
Y ahora me devuelvo aquí

588
00:27:22,779 --> 00:27:25,299
Personas

589
00:27:25,299 --> 00:27:38,109
Vale, ¿tenéis el método completo?

590
00:27:42,069 --> 00:27:43,549
Esta es la colección inicial

591
00:27:43,549 --> 00:27:44,809
Inicialmente vacía

592
00:27:44,809 --> 00:27:46,589
Puede que no haya personas con este nombre

593
00:27:46,589 --> 00:27:47,549
Inicialmente vacía

594
00:27:47,549 --> 00:27:49,869
nos hacemos nuestra select

595
00:27:49,869 --> 00:27:50,890
que ahora ha cambiado

596
00:27:50,890 --> 00:27:53,950
nos hacemos nuestra select, ahora es por nombre

597
00:27:53,950 --> 00:27:54,990
hay que poner esta comilla

598
00:27:54,990 --> 00:27:58,019
y ahora

599
00:27:58,019 --> 00:28:04,079
por cada registro, que ahora puedo tener muchos

600
00:28:04,079 --> 00:28:05,579
me construye una persona

601
00:28:05,579 --> 00:28:07,740
con esos datos y se la añado

602
00:28:07,740 --> 00:28:08,420
a la colección

603
00:28:08,420 --> 00:28:11,000
y devuelvo las personas

604
00:28:11,000 --> 00:28:13,359
vale, vamos a comprobar primero que funciona

605
00:28:13,359 --> 00:28:15,500
y luego ya le hacemos

606
00:28:15,500 --> 00:28:17,579
la inyección, que a esta sí que se la podremos hacer

607
00:28:17,579 --> 00:28:24,559
fácilmente, ah bueno que no me he hecho

608
00:28:24,559 --> 00:28:26,339
el main con el método

609
00:28:26,339 --> 00:28:37,269
recupera

610
00:28:37,269 --> 00:28:38,890
personas

611
00:28:38,890 --> 00:28:41,390
por nombre

612
00:28:41,390 --> 00:28:46,990
vale, pues será

613
00:28:46,990 --> 00:28:52,089
mi caso 3

614
00:28:52,089 --> 00:29:07,880
dame nombre

615
00:29:07,880 --> 00:29:22,359
vale, ya tengo su nombre

616
00:29:22,359 --> 00:29:23,599
y ahora ya

617
00:29:23,599 --> 00:29:25,740
voy a recorrer

618
00:29:25,740 --> 00:29:28,079
las personas para mostrarla

619
00:29:28,079 --> 00:29:30,200
para cada persona

620
00:29:30,200 --> 00:29:34,839
en operaciones.get

621
00:29:34,839 --> 00:29:36,720
no me digas que otra vez tampoco la he puesto

622
00:29:36,720 --> 00:29:38,019
static

623
00:29:38,019 --> 00:29:41,079
tampoco la he puesto static

624
00:29:41,079 --> 00:29:46,480
vale

625
00:29:46,480 --> 00:29:47,680
pues

626
00:29:47,680 --> 00:30:02,160
vale, amiga, dime

627
00:30:02,160 --> 00:30:17,660
a ver, no

628
00:30:17,660 --> 00:30:18,819
pero esto no lo hace

629
00:30:18,819 --> 00:30:21,619
no hace una llamada esto en cada

630
00:30:21,619 --> 00:30:22,279
iteración

631
00:30:22,279 --> 00:30:24,920
la hace al principio

632
00:30:24,920 --> 00:30:27,640
vale, o sea, no es que en cada

633
00:30:27,640 --> 00:30:29,880
iteración vuelva a sacarlas

634
00:30:29,880 --> 00:30:31,940
todas, no, no las vuelve a sacar

635
00:30:31,940 --> 00:30:36,039
todas, vale, pues bueno

636
00:30:36,039 --> 00:30:37,720
esto, dame el nombre

637
00:30:37,720 --> 00:30:39,819
y ahora ya recorro todas las personas

638
00:30:39,819 --> 00:30:41,960
en esa colección, vamos a

639
00:30:41,960 --> 00:30:42,859
probar primero

640
00:30:42,859 --> 00:30:44,940
aquí no hay nada lanzado

641
00:30:44,940 --> 00:30:49,009
sí, vamos a lanzarlo

642
00:30:49,009 --> 00:30:51,150
primero bien, metiéndole

643
00:30:51,150 --> 00:30:53,109
un dato bueno, no queremos romper nada

644
00:30:53,109 --> 00:30:58,849
a ver, una que tenga

645
00:30:58,849 --> 00:30:59,569
pues venga

646
00:30:59,569 --> 00:31:01,849
vamos a ver que pasa con

647
00:31:01,849 --> 00:31:07,220
Pepe, vale, pues aquí

648
00:31:07,220 --> 00:31:08,980
están los datos de Pepe, vale

649
00:31:08,980 --> 00:31:11,259
entonces yo ahora puedo

650
00:31:11,259 --> 00:31:11,920
meter

651
00:31:11,920 --> 00:31:14,220
una cosa

652
00:31:14,220 --> 00:31:16,700
y que me salga la base de datos entera

653
00:31:16,700 --> 00:31:19,460
¿qué cosa? pues vamos a pensarla

654
00:31:19,460 --> 00:31:19,720
aquí

655
00:31:19,720 --> 00:31:23,099
el string que él tiene es este

656
00:31:23,099 --> 00:31:25,640
nombre

657
00:31:25,640 --> 00:31:26,599
igual

658
00:31:26,599 --> 00:31:29,599
entonces, él tiene la comilla

659
00:31:29,599 --> 00:31:32,660
aquí el nombre que yo le dé

660
00:31:32,660 --> 00:31:37,680
y luego me cierra con comilla otra vez

661
00:31:37,680 --> 00:31:40,299
entonces, este es el nombre que yo le paso

662
00:31:40,299 --> 00:31:44,180
¿qué le podemos pasar ahí para convertir este word en un true?

663
00:31:45,000 --> 00:31:47,480
pues le podemos pasar cualquier cosa

664
00:31:47,480 --> 00:31:50,759
lo que me dé, un nombre que yo ni conozco de la base de datos

665
00:31:50,759 --> 00:31:51,960
or

666
00:31:51,960 --> 00:31:56,420
pongo una comilla otra vez, 1 la cierro

667
00:31:56,420 --> 00:32:00,019
Igual a

668
00:32:00,019 --> 00:32:01,400
Abro la comilla y pongo el 1

669
00:32:01,400 --> 00:32:04,140
Es decir, si yo le pongo esto

670
00:32:04,140 --> 00:32:06,099
Ya he convertido

671
00:32:06,099 --> 00:32:07,220
Un true, ¿no?

672
00:32:13,670 --> 00:32:14,430
Ah, me falta

673
00:32:14,430 --> 00:32:18,109
No, no

674
00:32:18,109 --> 00:32:18,990
Eh

675
00:32:18,990 --> 00:32:19,289
Eh

676
00:32:19,289 --> 00:32:32,130
Ya, ya, ya, sé que me estáis diciendo

677
00:32:32,130 --> 00:32:33,130
eso, pero

678
00:32:33,130 --> 00:32:45,869
entonces

679
00:32:45,869 --> 00:32:47,869
no, es que no

680
00:32:47,869 --> 00:33:22,420
vale, esta sí está bien

681
00:33:22,420 --> 00:33:24,519
vale, entonces

682
00:33:24,519 --> 00:33:26,059
esto

683
00:33:26,059 --> 00:33:28,660
es lo que le tengo que meter

684
00:33:28,660 --> 00:33:30,740
¿verdad? cualquier cosa ahí

685
00:33:30,740 --> 00:33:33,799
dime

686
00:33:33,799 --> 00:33:40,599
a ver

687
00:33:40,599 --> 00:33:42,140
esto es algo que es verdad

688
00:33:42,140 --> 00:33:44,759
¿no? uno igual a uno es verdad, como si pongo

689
00:33:44,759 --> 00:33:46,180
2 igual a 2, 3 igual a 3

690
00:33:46,180 --> 00:33:47,619
entonces al hacer un or

691
00:33:47,619 --> 00:33:49,480
con algo que es verdad

692
00:33:49,480 --> 00:33:52,119
entonces me queda nombre igual a pepe

693
00:33:52,119 --> 00:33:54,380
o verdad, entonces aunque este nombre

694
00:33:54,380 --> 00:33:56,319
no exista, la condición

695
00:33:56,319 --> 00:33:56,980
va a ser verdad

696
00:33:56,980 --> 00:34:00,220
entonces yo tengo que meter algo que me construya

697
00:34:00,220 --> 00:34:01,940
este SQL, lo que me aporta

698
00:34:01,940 --> 00:34:04,279
esta primera comilla, ya está

699
00:34:04,279 --> 00:34:06,279
entonces es esto lo que tengo que meter

700
00:34:06,279 --> 00:34:08,360
¿verdad? sería esto lo que tengo que meter

701
00:34:08,360 --> 00:34:10,059
entonces

702
00:34:10,059 --> 00:34:15,030
por ejemplo

703
00:34:15,030 --> 00:34:16,030
esto mismo

704
00:34:16,030 --> 00:34:23,059
¿Vale? Cualquier cosa que le ponga

705
00:34:23,059 --> 00:34:23,440
Yo aquí

706
00:34:23,440 --> 00:34:25,099
Esto

707
00:34:25,099 --> 00:34:29,019
¿Vale? Da igual lo que yo ponga ahí da lo mismo

708
00:34:29,019 --> 00:34:30,460
Entonces

709
00:34:30,460 --> 00:34:35,829
Yo ahora voy a decir

710
00:34:35,829 --> 00:34:38,210
A ver, no tengo ni idea

711
00:34:38,210 --> 00:34:38,809
De

712
00:34:38,809 --> 00:34:41,570
Recuperar personas por nombre

713
00:34:41,570 --> 00:34:44,030
Esto es nombre

714
00:34:44,030 --> 00:34:45,710
Pero podría ser contraseña o la que fuera

715
00:34:45,710 --> 00:34:47,570
Yo no tengo ni idea de lo que hay en la base de datos

716
00:34:47,570 --> 00:34:48,110
Pero

717
00:34:48,110 --> 00:34:50,849
Aquí me funciona

718
00:34:50,849 --> 00:34:53,449
esto, le meto esto

719
00:34:53,449 --> 00:34:55,190
no tengo ni idea de nombres o algo así

720
00:34:55,190 --> 00:34:57,369
y me saca

721
00:34:57,369 --> 00:34:58,110
toda la tabla

722
00:34:58,110 --> 00:35:04,590
¿vale? entonces es una forma

723
00:35:04,590 --> 00:35:06,750
sencilla de sacar todos los contenidos de una tabla

724
00:35:06,750 --> 00:35:10,679
¿qué ocurre?

725
00:35:11,139 --> 00:35:12,800
claro, que efectivamente

726
00:35:12,800 --> 00:35:15,119
esto no tiene solución, es que

727
00:35:15,119 --> 00:35:17,280
esto es así sí o sí, y probando

728
00:35:17,280 --> 00:35:19,099
con un montón de

729
00:35:19,099 --> 00:35:20,480
datos de formularios

730
00:35:20,480 --> 00:35:22,900
perfectamente, rápidamente

731
00:35:22,900 --> 00:35:25,000
vas a romper la seguridad y te va a salir

732
00:35:25,000 --> 00:35:26,099
ahí todo lo de la tabla

733
00:35:26,099 --> 00:35:29,219
Claro, pues precisamente por eso

734
00:35:29,219 --> 00:35:30,980
Hay una sentencia alternativa

735
00:35:30,980 --> 00:35:32,300
A esta de aquí

736
00:35:32,300 --> 00:35:36,500
A esta

737
00:35:36,500 --> 00:35:38,599
¿Vale?

738
00:35:39,800 --> 00:35:40,480
Vale

739
00:35:40,480 --> 00:35:44,320
Pues vamos a parar unos minutos

740
00:35:44,320 --> 00:35:46,099
Luego completamos con esta sentencia

741
00:35:46,099 --> 00:35:48,239
Y lo dejamos por hoy