1
00:00:02,040 --> 00:00:09,080
Continuamos con el tema dedicado a la creación de módulos, funciones y procedimientos con un ejemplo de una función.

2
00:00:10,019 --> 00:00:15,119
En este caso, lo que he hecho ha sido crear una función que se llama hijos de empleados,

3
00:00:15,619 --> 00:00:25,019
que básicamente lo que hace es que le paso como parámetro un número de hijos y me devuelve cuántos empleados hay que tienen ese número de hijos.

4
00:00:25,920 --> 00:00:38,380
El cuerpo de la función sería este, siempre la misma estructura, creatore, clase, función, número de la función, parámetro de entrada, hijos, y fijaros en el valor de vuelta.

5
00:00:38,560 --> 00:00:51,359
En el valor de vuelta se indica tanto el tipo y la variable con el tipo que lo va a recoger, en la que se va a devolver.

6
00:00:51,359 --> 00:00:55,640
En algunos lenguajes de programación se utiliza el nombre de la función

7
00:00:55,640 --> 00:00:58,259
Con lo cual no haría falta declarar esto

8
00:00:58,259 --> 00:01:03,100
Simplemente el tipo de dato y luego poner un return con el nombre de la función

9
00:01:03,100 --> 00:01:09,000
Ya ves que en PSQL además del nombre de la función y del tipo de dato

10
00:01:09,000 --> 00:01:16,260
Hay que declarar la variable con su tipo que lo va a recoger

11
00:01:16,260 --> 00:01:19,700
Diréis, ¿por qué aparece IntegrityNumber?

12
00:01:19,700 --> 00:01:32,799
Bien, aparece por lo siguiente, porque yo en la base de datos lo he creado como integer, pero luego en PLSQL no existe el tipo integer, sino que es number.

13
00:01:33,780 --> 00:01:42,640
¿Qué es lo que hace? Bueno, esta función lo que hace es que declara un cursor implícito, ya que va a devolver una única fila con el número de empleado,

14
00:01:42,640 --> 00:01:44,099
que es un count

15
00:01:44,099 --> 00:01:45,859
que lo vuelca

16
00:01:45,859 --> 00:01:49,000
en el valor que voy a utilizar de vuelta

17
00:01:49,000 --> 00:01:50,980
en la variable que voy a utilizar

18
00:01:50,980 --> 00:01:52,099
para el valor de vuelta

19
00:01:52,099 --> 00:01:54,560
y que selecciona de la tabla empleado

20
00:01:54,560 --> 00:01:57,099
me cuenta todos los empleados

21
00:01:57,099 --> 00:01:58,980
que tienen el número de hijos igual

22
00:01:58,980 --> 00:02:00,900
a hijos que es el valor que le he pasado

23
00:02:00,900 --> 00:02:02,980
como argumento y después lo devuelve

24
00:02:04,140 --> 00:02:04,640
¿de acuerdo?

25
00:02:07,540 --> 00:02:09,000
en otra hoja

26
00:02:09,000 --> 00:02:10,379
PLSQL

27
00:02:10,379 --> 00:02:14,780
perdón, otra hoja SQL que puedo abrir

28
00:02:14,780 --> 00:02:18,939
indicando aquí, indicando sobre la conexión que se hace

29
00:02:18,939 --> 00:02:21,860
¿Veis? Aquí abrí una y pego el código

30
00:02:21,860 --> 00:02:26,759
pues hago la llamada. ¿Qué es lo que hace la llamada? Bueno, habilita

31
00:02:26,759 --> 00:02:30,099
la salida y

32
00:02:30,099 --> 00:02:34,419
declara dos variables. La primera es hijos, que la va a pedir

33
00:02:34,419 --> 00:02:38,560
y la segunda es cont, que es

34
00:02:38,560 --> 00:02:41,120
donde la va a recoger, fijaros que la declaro

35
00:02:41,120 --> 00:02:42,000
dando como entero

36
00:02:42,000 --> 00:02:44,599
entonces, esto me pediría

37
00:02:44,599 --> 00:02:45,780
¿cuántos números de hijos?

38
00:02:47,379 --> 00:02:49,099
y lo que hace el código

39
00:02:49,099 --> 00:02:51,479
es que, como os decía

40
00:02:51,479 --> 00:02:52,900
al ser una función

41
00:02:52,900 --> 00:02:54,199
un módulo que devuelve un valor

42
00:02:54,199 --> 00:02:57,240
para llamarlo, necesito una variable

43
00:02:57,240 --> 00:02:59,180
que recoja ese valor, en este caso

44
00:02:59,180 --> 00:03:00,340
es la variable cont

45
00:03:00,340 --> 00:03:02,860
entonces se pone una cosa parecida a esta

46
00:03:02,860 --> 00:03:05,219
cont va a ser igual a lo que devuelva

47
00:03:05,219 --> 00:03:07,840
hijo empleado que devuelve hijos

48
00:03:07,840 --> 00:03:11,199
esto llamaría a la función

49
00:03:11,199 --> 00:03:12,560
haría el select

50
00:03:12,560 --> 00:03:15,319
el valor se devuelve en cont

51
00:03:15,319 --> 00:03:16,860
y se almacena en cont

52
00:03:16,860 --> 00:03:18,620
no tiene por qué llamarse igual

53
00:03:18,620 --> 00:03:19,919
pero bueno, la llama de igual

54
00:03:19,919 --> 00:03:22,599
y lo que hace es que

55
00:03:22,599 --> 00:03:24,539
si comprueba que sea cero

56
00:03:24,539 --> 00:03:26,020
para decirme que no hay empleados

57
00:03:26,020 --> 00:03:26,539
con

58
00:03:26,539 --> 00:03:31,500
ese número de hijos

59
00:03:31,500 --> 00:03:33,900
he puesto ese con esos hijos

60
00:03:33,900 --> 00:03:37,620
y si no

61
00:03:37,620 --> 00:03:54,520
pues me dice que hay empleados con hijos, ¿vale? Bien, os he dicho que hasta ahora no hemos dejado almacenados los bloques anónimos de PLSQL,

62
00:03:54,759 --> 00:04:02,860
pero sí se pueden almacenar, no me riñáis, sé que lo tenía que haber dicho antes. ¿Cómo se pueden guardar estos bloques de PLSQL?

63
00:04:02,860 --> 00:04:22,740
Pues se pueden guardar como si fuese una función normal y corriente, como si fuese un archivo normal y corriente. Entonces yo le digo guardar como porque ya lo he guardado y me va a la carpeta root. Yo lo que he hecho ha sido crearme una carpetita empleados, que la puedo crear aquí, ¿vale?

64
00:04:22,740 --> 00:04:31,379
y dentro de ese le pongo un nombre, le he puesto llamada, función, nombre de la función, llamada, procedimiento,

65
00:04:31,540 --> 00:04:36,920
este es el de antes, lo guardo y ya lo tengo ahí disponible.

66
00:04:38,920 --> 00:04:46,560
Vamos a comprobar que funciona, como siempre primero lo compilamos, veis que no da error, compilado,

67
00:04:46,560 --> 00:04:51,480
y ahora lo comprobamos utilizando la llamada.

68
00:04:52,740 --> 00:04:56,000
cuando lo ejecuto

69
00:04:56,000 --> 00:04:58,199
perdón, le tenía que haber dado aquí

70
00:04:58,199 --> 00:05:00,699
bueno, igual

71
00:05:00,699 --> 00:05:01,980
me dice que

72
00:05:01,980 --> 00:05:04,839
con qué conexión lo quiero ejecutar

73
00:05:04,839 --> 00:05:06,879
por defecto me coge

74
00:05:06,879 --> 00:05:08,860
la que tengo abierta, me pide el número de hijos

75
00:05:08,860 --> 00:05:10,500
pues bueno, le voy a poner 2

76
00:05:10,500 --> 00:05:12,339
pues me dice

77
00:05:12,339 --> 00:05:14,500
como resultado que hay

78
00:05:14,500 --> 00:05:16,480
6 empleados con 2 hijos

79
00:05:16,480 --> 00:05:18,540
lo voy a volver a ejecutar

80
00:05:18,540 --> 00:05:20,480
y le voy a poner un valor que sé que no hay

81
00:05:20,480 --> 00:05:21,439
12 hijos

82
00:05:21,439 --> 00:05:27,399
para que me diga que no hay empleados con esos 12 hijos

83
00:05:27,399 --> 00:05:29,279
de acuerdo

84
00:05:29,279 --> 00:05:33,839
de esa manera

85
00:05:33,839 --> 00:05:37,139
lo guardo, si

86
00:05:37,139 --> 00:05:40,779
de esa manera, a ver si me deja

87
00:05:40,779 --> 00:05:47,579
pues tenemos que el procedimiento o función queda almacenado en la conexión

88
00:05:47,579 --> 00:05:48,500
como ya vimos

89
00:05:48,500 --> 00:06:09,819
Aquí abro la función y aquí abro el procedimiento y la llamada pues puedo acceder a ella en cualquier momento abriendo mi carpetita de base de datos y voy a volver por ejemplo a abrir otra vez la llamada al procedimiento.

90
00:06:09,819 --> 00:06:12,480
la ejecuto

91
00:06:12,480 --> 00:06:15,420
número de departamento

92
00:06:15,420 --> 00:06:17,079
pues el 120

93
00:06:17,079 --> 00:06:19,139
aceptar

94
00:06:19,139 --> 00:06:21,399
solo hay un empleado

95
00:06:21,399 --> 00:06:22,939
en el departamento 120

96
00:06:22,939 --> 00:06:25,000
vale

97
00:06:25,000 --> 00:06:27,500
muy bien, entonces un saludo y hasta luego