1
00:00:01,010 --> 00:00:06,309
Vamos a trabajar con JDBC aplicado a la base de datos SQLite.

2
00:00:06,710 --> 00:00:18,050
Lo primero que necesitamos es una base de datos SQLite, ya he generado yo por aquí una, vamos a acceder a ese fichero, se llama datos.sqlite, la base de datos,

3
00:00:18,050 --> 00:00:29,609
y si vemos el esquema de la base de datos hay una tabla que se llama datos, que tiene un campo que se llama número y que es un entero y clave primaria

4
00:00:29,609 --> 00:00:44,250
y texto de tipo text y no admite nulos. Si vemos la información que tiene almacenada, vamos a ver que hay almacenado en esta base de datos

5
00:00:44,250 --> 00:00:48,609
Pues vemos que hay un campo 2, unos números con su texto alrededor

6
00:00:48,609 --> 00:00:52,929
Bien, conociendo que tenemos esta base de datos ya creada

7
00:00:52,929 --> 00:00:59,270
Lo que vamos a hacer ahora es obtener todo lo necesario para montar un programa Java

8
00:00:59,270 --> 00:01:04,370
Que se conecte a esta base de datos y nos devuelva la información que contiene

9
00:01:04,370 --> 00:01:09,810
Bien, para ello lo primero que necesitamos es tener un conector JDBC

10
00:01:09,810 --> 00:01:36,430
JDBC su propio nombre es Java Database Connector, entonces vamos a buscar donde podemos encontrar un JDBC de SQLite, vamos a la primera entrada que nos aparece buscando en Google mínimamente y vemos que en la parte aquí de comentarios nos aparece que podemos descargar en esta web el propio JDBC para SQLite.

11
00:01:36,430 --> 00:01:39,049
vamos a ello, vamos a ir a la última versión

12
00:01:39,049 --> 00:01:41,189
que es esta de aquí, la 3.34.0

13
00:01:41,189 --> 00:01:43,209
y dentro de ella queremos

14
00:01:43,209 --> 00:01:44,549
un fichero que se llama jar

15
00:01:44,549 --> 00:01:46,650
justamente este de aquí

16
00:01:46,650 --> 00:01:49,489
nosotros tienen que ver con documentación y fuentes

17
00:01:49,489 --> 00:01:51,810
y nosotros queremos ya el ejecutable

18
00:01:51,810 --> 00:01:53,450
o la librería para enlazar

19
00:01:53,450 --> 00:01:55,010
con ese culite

20
00:01:55,010 --> 00:01:57,569
la descargo, la voy a guardar

21
00:01:57,569 --> 00:01:59,950
en mi ordenador

22
00:01:59,950 --> 00:02:01,269
y ahora

23
00:02:01,269 --> 00:02:03,049
aquí desde descargas

24
00:02:03,049 --> 00:02:05,290
por lo lógico que no hay un sitio mejor que descargas

25
00:02:05,290 --> 00:02:10,550
Por ejemplo, me la voy a llevar directamente al sitio donde estoy trabajando de Eclipse.

26
00:02:10,789 --> 00:02:15,310
Me voy a Eclipse Workspace y como estoy trabajando aquí justamente,

27
00:02:15,550 --> 00:02:19,750
pues podría ponerla en este directorio o en el directorio de Eclipse para que me valga para cualquier programa.

28
00:02:20,229 --> 00:02:22,710
Voy a darle ahí y aquí la tengo.

29
00:02:23,870 --> 00:02:27,949
Una vez que ya la tengo, puedo empezar a programar. Esto ya después lo enlazaremos.

30
00:02:29,090 --> 00:02:29,750
Vamos a Eclipse.

31
00:02:29,750 --> 00:02:41,889
Vamos a crear una clase que sea leer ese culite, por ejemplo.

32
00:02:42,169 --> 00:02:48,370
Vamos a llamarla así y vamos a darle que crea ya directamente nuestro programa principal.

33
00:02:50,289 --> 00:02:57,449
Voy a borrar esto de aquí y vamos a crear nuestra primera clase para acceder a la base de datos.

34
00:02:57,449 --> 00:03:11,030
Voy a crear una clase estática, static, void, que voy a llamar acceso, acceso, database, base de datos.

35
00:03:11,310 --> 00:03:14,990
Muy bien. Por ejemplo, esta, la cual yo llamaré después desde aquí.

36
00:03:19,740 --> 00:03:25,039
¿Cómo me conecto a una base de datos? Pues lo primero que tengo que hacer es obtener un conector.

37
00:03:25,479 --> 00:03:30,500
¿Y cómo establezco esa conexión? Pues a través de un identificador de recursos.

38
00:03:31,580 --> 00:03:36,280
que voy indicándole que lo que quiero es un JDBC,

39
00:03:37,560 --> 00:03:40,879
lo siguiente es el tipo de base de datos a la que yo me quiero conectar,

40
00:03:41,259 --> 00:03:43,020
en este caso es SQLite,

41
00:03:43,020 --> 00:03:48,479
y ahora el nombre de esa base de datos, en el caso de SQLite,

42
00:03:48,580 --> 00:03:51,259
como es la ruta a un fichero, pues esto de aquí.

43
00:03:52,099 --> 00:03:55,280
Ya veremos cuando veamos un ejemplo con MariaDB o MySQL

44
00:03:55,280 --> 00:03:57,000
que nos hará falta algún elemento más.

45
00:03:57,960 --> 00:04:00,139
Bueno, pues de momento vamos a crear un conector.

46
00:04:00,139 --> 00:04:16,199
Voy a crear un conector, entonces me hace falta conectarme con el driver del SQLite y obtener un conector, un conector de esa URI que acabo de generar.

47
00:04:16,379 --> 00:04:23,360
Muy bien, nos aparece el primer problema y es que aquí esto no está definido, con lo cual vamos a ver cómo lo hacemos y aquí hay varias opciones.

48
00:04:23,360 --> 00:04:27,180
Yo voy a optar por javasql, opten siempre por javasql.

49
00:04:27,180 --> 00:04:32,720
vale, este error ya ha desaparecido, ya está aquí contenido

50
00:04:32,720 --> 00:04:35,860
en la importación y ahora nos aparece aquí

51
00:04:35,860 --> 00:04:40,759
que claro, puede ocurrir que no encontremos esta base de datos

52
00:04:40,759 --> 00:04:44,120
con lo cual esto nos está pidiendo, voy a bajar un poquito

53
00:04:44,120 --> 00:04:48,639
nos está pidiendo que lo bloqueemos con algo

54
00:04:48,639 --> 00:04:52,540
que salte una excepción en caso de error, bueno, pues de momento

55
00:04:52,540 --> 00:04:56,199
vamos a trabajar en esta parte, lo siguiente que nos aparece es un mensaje

56
00:04:56,199 --> 00:05:00,620
aquí en amarillo y nos dice que esto nunca se cierra, recuerden que esto es un flujo

57
00:05:00,620 --> 00:05:03,680
como otro cualquiera y que todos los grifos hay que cerrarlos

58
00:05:03,680 --> 00:05:08,259
pues ya tenemos aquí nuestra conexión

59
00:05:08,259 --> 00:05:12,439
vale, es el momento ya de ir directamente a buscar información

60
00:05:12,439 --> 00:05:16,199
de nuestras tablas, de nuestros datos que están metidos en esa tabla

61
00:05:16,199 --> 00:05:19,939
yo no recuerdo los campos que habíamos metido, aquí los tenemos

62
00:05:19,939 --> 00:05:23,459
número y texto from datos, pues vamos a intentar hacer esto directamente

63
00:05:23,459 --> 00:05:48,699
Entonces lo primero es construir nuestra sentencia SQL, entonces vamos a crear un string que llamo SQL y voy a copiar directamente esa sentencia, select, número y mi memoria es mínima, texto, from datos, texto, from datos, muy bien.

64
00:05:48,699 --> 00:05:51,420
¿Qué es lo que yo quiero hacer ahora?

65
00:05:51,860 --> 00:05:54,699
Pues lo que quiero es preparar una sentencia

66
00:05:54,699 --> 00:06:00,939
Entonces vamos a llamar a una cuestión que es PrepareStatement

67
00:06:00,939 --> 00:06:03,500
Voy a darle este nombre

68
00:06:03,500 --> 00:06:08,579
Y lo que voy a hacer es conectarme a ese conector que he generado

69
00:06:08,579 --> 00:06:11,699
Y preparar esta sentencia

70
00:06:12,259 --> 00:06:15,540
PrepareStatement

71
00:06:15,540 --> 00:06:17,180
Este primer caso me vale

72
00:06:17,180 --> 00:06:18,639
¿Y qué le paso aquí?

73
00:06:18,699 --> 00:06:21,120
pues le paso directamente la SQL

74
00:06:21,120 --> 00:06:22,920
que he generado

75
00:06:22,920 --> 00:06:25,480
como siempre nos falta la librería

76
00:06:25,480 --> 00:06:26,160
pues le damos

77
00:06:26,160 --> 00:06:28,620
importamos, recordemos que es

78
00:06:28,620 --> 00:06:31,079
javasql, que es ese interfaz

79
00:06:31,079 --> 00:06:32,480
neutro que nos va a permitir

80
00:06:32,480 --> 00:06:35,180
conectarnos a cualquier sistema gestor de bases de datos

81
00:06:35,180 --> 00:06:36,939
y seguimos trabajando

82
00:06:36,939 --> 00:06:39,240
el amarillo ahora mismo simplemente dice que no utilizamos

83
00:06:39,240 --> 00:06:40,399
PS para nada

84
00:06:40,399 --> 00:06:43,100
bueno, lo siguiente, ya hemos preparado la sentencia

85
00:06:43,100 --> 00:06:44,399
lo siguiente es ejecutarla

86
00:06:44,399 --> 00:06:47,199
entonces lo que vamos a obtener es un conjunto

87
00:06:47,199 --> 00:06:49,000
de resultados, un result set

88
00:06:49,000 --> 00:06:51,379
rs

89
00:06:51,379 --> 00:06:53,339
vamos a darle ya aquí

90
00:06:53,339 --> 00:06:54,680
para que no lo vaya cargando

91
00:06:54,680 --> 00:06:57,019
o igual que antes javasql

92
00:06:57,019 --> 00:06:58,600
vale

93
00:06:58,600 --> 00:07:00,579
rs punto

94
00:07:00,579 --> 00:07:02,980
y aquí podemos ejecutar

95
00:07:02,980 --> 00:07:04,759
directamente execute

96
00:07:04,759 --> 00:07:06,879
voy a seleccionar de lo que había aquí

97
00:07:06,879 --> 00:07:09,040
perdón, aquí no es rs

98
00:07:09,040 --> 00:07:11,139
sino la sentencia preparada que tenía antes

99
00:07:11,139 --> 00:07:13,319
execute query

100
00:07:13,319 --> 00:07:16,240
muy bien

101
00:07:16,240 --> 00:07:18,279
pues ya tengo la sentencia

102
00:07:18,279 --> 00:07:19,459
ejecutada

103
00:07:19,459 --> 00:07:22,540
ahora podría por ejemplo

104
00:07:22,540 --> 00:07:24,040
obtener un registro

105
00:07:24,040 --> 00:07:26,420
el primer registro, vamos a obtener

106
00:07:26,420 --> 00:07:27,959
el primer registro, a ver que hace

107
00:07:27,959 --> 00:07:30,639
rs.next

108
00:07:30,639 --> 00:07:32,480
y si quiero cualquiera

109
00:07:32,480 --> 00:07:34,199
de los valores que tengo ahí, vamos a

110
00:07:34,199 --> 00:07:36,420
poner un mensaje que nos

111
00:07:36,420 --> 00:07:38,600
permita ver lo que estamos

112
00:07:38,600 --> 00:07:40,600
obteniendo, pues puedo decir

113
00:07:40,600 --> 00:07:42,540
rs.get

114
00:07:42,540 --> 00:07:44,439
el primer caso es

115
00:07:44,439 --> 00:07:46,120
un número, que es un número entero

116
00:07:46,120 --> 00:08:09,819
Pues int y el argumento 1 y en el segundo caso voy a ponerlo así, perdón, así, dos puntitos y rc.get, en el segundo caso era un string, getString, getString del 2.

117
00:08:09,819 --> 00:08:13,819
igual que estoy poniendo 1 y 2, podría haber puesto entre comillas

118
00:08:13,819 --> 00:08:18,339
número y entre comillas texto, cualquiera de las dos formas me recuperaría el registro

119
00:08:18,339 --> 00:08:21,100
muy bien, bueno, con esto yo ya me animaría

120
00:08:21,100 --> 00:08:26,019
a ejecutar el programa, pero hay algo

121
00:08:26,019 --> 00:08:30,199
que me falla, y es que no tengo asociado a mi proyecto esa librería

122
00:08:30,199 --> 00:08:33,919
que hemos bajado, esta librería que teníamos por aquí, esta, todavía no está

123
00:08:33,919 --> 00:08:37,480
asociada a mi proyecto, entonces, pues nada, para hacer eso

124
00:08:37,480 --> 00:08:38,960
me pongo el mismo proyecto

125
00:08:38,960 --> 00:08:41,480
y o bien voy a build path

126
00:08:41,480 --> 00:08:43,019
y configuro el build path

127
00:08:43,019 --> 00:08:45,399
o voy a las propiedades y voy al mismo sitio

128
00:08:45,399 --> 00:08:46,759
como más rabia me dé

129
00:08:46,759 --> 00:08:49,340
voy a ir por propiedades, me voy a java build path

130
00:08:49,340 --> 00:08:51,620
y aquí en class path voy a añadir

131
00:08:51,620 --> 00:08:52,419
ese jar

132
00:08:52,419 --> 00:08:54,340
si lo quiero dejar como externo

133
00:08:54,340 --> 00:08:56,840
pues habrá que enlazarlo cada vez

134
00:08:56,840 --> 00:08:59,519
si queremos lo podemos incluir como parte del proyecto

135
00:08:59,519 --> 00:09:01,059
de momento lo voy a poner como externo

136
00:09:01,059 --> 00:09:02,899
voy aquí a eclipse

137
00:09:02,899 --> 00:09:04,519
selecciono

138
00:09:04,519 --> 00:09:06,460
este ficherito

139
00:09:06,460 --> 00:09:08,419
y aplico esto ya

140
00:09:08,419 --> 00:09:09,700
y lo puedo cerrar

141
00:09:09,700 --> 00:09:12,919
muy bien, pues si esto está bien programado

142
00:09:12,919 --> 00:09:14,779
podríamos ya ver

143
00:09:14,779 --> 00:09:16,799
este primer registro de num

144
00:09:16,799 --> 00:09:18,200
de esta tabla

145
00:09:18,200 --> 00:09:20,679
que tenemos aquí, vamos a ejecutar

146
00:09:20,679 --> 00:09:24,659
ejecutamos

147
00:09:24,659 --> 00:09:29,720
y efectivamente nos sale el primer registro

148
00:09:29,720 --> 00:09:31,980
que obteníamos, 2.2

149
00:09:31,980 --> 00:09:33,600
¿vale? bueno

150
00:09:33,600 --> 00:09:35,899
este era el primero

151
00:09:35,899 --> 00:09:37,899
que teníamos, si quisiéramos ver todos

152
00:09:37,899 --> 00:09:39,740
todos los que tenemos

153
00:09:39,740 --> 00:09:41,740
aquí, pues podríamos

154
00:09:41,740 --> 00:09:43,419
hacer un bucle simplemente

155
00:09:43,419 --> 00:09:45,620
mientras se

156
00:09:45,620 --> 00:09:51,000
cumpla esto, pues entonces

157
00:09:51,000 --> 00:09:52,720
vamos a mostrar

158
00:09:52,720 --> 00:09:54,519
estos dos campos

159
00:09:54,519 --> 00:09:56,559
podríamos hacerlo así perfectamente

160
00:09:56,559 --> 00:10:00,659
vamos a por ello, y efectivamente

161
00:10:00,659 --> 00:10:02,039
nos sale toda la información

162
00:10:02,039 --> 00:10:04,399
bueno, esta es una manera muy simple de trabajar

163
00:10:04,399 --> 00:10:06,460
con una base de datos

164
00:10:06,460 --> 00:10:08,440
en este caso SQLite, pero ya veremos que

165
00:10:08,440 --> 00:10:10,519
con MSQL o

166
00:10:10,519 --> 00:10:12,179
MariaDB va a ser exactamente

167
00:10:12,179 --> 00:10:13,340
igual