24:24
2025-01-27 13:13:59
2:06:12
2025-01-27 13:42:41
3:36:29
2025-01-28 09:08:14
4:33
2025-01-28 13:48:42
55:46
2025-01-28 14:06:51
2:02
2025-01-29 10:22:33
1:02:14
2025-01-29 10:25:14
2:10
2025-01-29 11:38:26
2:26
2025-01-29 12:03:00
1:23:37
2025-01-29 12:05:56
35:40
2025-01-29 15:01:26
1:40:43
2025-01-30 09:07:07
1:08:48
2025-01-30 11:20:20
1:10:50
2025-01-30 13:15:56
3:50:03
2025-01-31 07:20:07
Visit the Talend Big Data Integration y Ecosistema de Talend course recordings page
United Arab Emirates - Talend Big Data Integration
WEBVTT
-->
perfecto, listo. Bien, eh, para
-->
iniciar el día de hoy, vamos a
-->
hacer entonces lo siguiente.
-->
Primero nos vamos al
-->
hipervisor de Hyper-V. Eh,
-->
vamos entonces aquí en el
-->
escritorio. Accedemos entonces
-->
al acceso directo que tenemos
-->
en el mismo escritorio. Y
-->
debería aparecer la máquina
-->
virtual como guardada, que fue
-->
lo que hicimos el día de
-->
ayer. La idea de esa guardada
-->
es que quedaba exactamente en
-->
el estado en que estaba
-->
anteriormente. Es decir, para
-->
evitar entonces subir nuevamente
-->
los servicios, aunque pude haber
-->
hecho esos servicios de manera
-->
automática, pero listo, la
-->
tengo de esa manera. Vamos
-->
entonces, dale doble clic para
-->
que inicie. Y le damos
-->
entonces eh, clic en el botón
-->
iniciar y debería llevarnos
-->
al estado en que la dejamos
-->
el día de ayer. Vamos a
-->
comprobar ese estado de la
-->
siguiente forma. Abra el
-->
browser que utilizó el día de
-->
ayer para conectarse al al
-->
clóster de Jadut y mostrar las
-->
gráficas a nivel de lo que
-->
contenía ese clóster. Yo si no
-->
estoy mal usé Edge. Y voy a
-->
darle a dirección diez punto
-->
diez punto cero punto tres
-->
punto dieciséis punto noventa
-->
ocho setenta. Y debería
-->
tener entonces los archivos
-->
que trabajamos el día de ayer.
-->
El caso de Beatriz eh noto que
-->
está perfecto. Alejandro
-->
también lo tiene perfecto.
-->
Fernanda está iniciando los
-->
servicios. Brenda lo tiene
-->
perfecto. Brenda eh si está
-->
mal le vaya a ser al en ese
-->
en ese al menú utilities que
-->
está al final y dele browse
-->
para comprobar que los
-->
archivos no hayan sufrido
-->
dele clic en AXA por favor.
-->
A ver ¿Por qué hacemos
-->
esto? El problema que tenemos
-->
con esta parte es que esta es
-->
una máquina virtual de una
-->
máquina virtual entonces puede
-->
haber algún problema con
-->
algún dato específico. Eh
-->
Luis no sé si a ti te está
-->
fucionando no sé mira para
-->
ver si. Exactamente dale F5
-->
ahí para ver. Perfecto está
-->
bien entonces. Vete a
-->
utilities por favor browse.
-->
Mientras vayamos también
-->
subiendo el talent big data
-->
se me escapaba que vamos a
-->
trabajar entonces talent big
-->
data por favor no lo había
-->
subido. Brenda anda voy
-->
contigo entonces eh Liso
-->
vamos a ver voy a ver voy a
-->
acceder a tu máquina ¿OK?
-->
Beatriz ejecute el otro
-->
exactamente había ejecutado
-->
el la versión comercial que
-->
había instalado ahí entonces
-->
voy a ver un momento aquí
-->
está ejecutando
-->
es el el talent eh sí ese que
-->
abrió usted inicialmente es el
-->
talent estudio pero necesitado
-->
que abría ahora por favor el
-->
talent big data y fue el día
-->
de ayer vamos a ver un
-->
momento
-->
no si todo bien Fernanda lo
-->
que es que no haya abierto
-->
el browse pero todo está bien
-->
aquí ahí está todo perfecto
-->
eh Fernanda si está amable
-->
sube el talent big data si
-->
si está amable lo mismo que
-->
Luis también para que sube el
-->
talent big data esa máquina
-->
virtual la dejamos quieta
-->
Pavel no sé si tú eh
-->
configuraste eso ayer no
-->
recuerdo sube el talent big
-->
data por favor es es Pavel
-->
el que subiste el talent
-->
estudio es el segundo que está
-->
del ese que está ahí ese que
-->
está ahí bueno vamos entonces
-->
a iniciar el día de hoy como
-->
venía comentando los
-->
ejemplos del día de ayer
-->
eh estuvieron más relacionados
-->
con la parte de
-->
almacenamiento eh
-->
específicamente el día de
-->
ayer nos conectamos a un S3
-->
y nos conectamos al cluster
-->
que que está configurado en
-->
la máquina virtual eh de a
-->
Hyper VIP hoy en día pues
-->
normalmente estos clústeres es
-->
muy raro a nivel de
-->
infraestructura un problema
-->
es que alguien los monte
-->
seguramente te vas a conectar
-->
alguna solución en la nube
-->
ya sea un MR un tipo sin
-->
el tipo de clústeres más que
-->
de que tengas por ejemplo de
-->
de Azure para conectarse a
-->
este tipo de clúster o en su
-->
defecto eh no utilizas eh
-->
HDFS para almacenar si no
-->
utilizas un object store
-->
C de tipo S3 tipo block el
-->
que tú quieras entonces ya
-->
la parte del almacenamiento
-->
está más diversa con
-->
respecto a lo que se tenía
-->
anteriormente anteriormente
-->
para Big Data me casaba
-->
mucho con la parte de de
-->
Hadut eh aunque los verbos
-->
de almacenamiento para almacenar
-->
y procesar hoy en día hay un
-->
algo más eh más conceptual un
-->
poco en definir Big Data es
-->
cuando proceso no tanto
-->
cuando almaceno partiendo
-->
del hecho en que ya yo tengo
-->
diferentes opciones para
-->
almacenar los datos que yo
-->
quiera procesar entonces hoy
-->
en día se tiene más en
-->
cuenta Big Data es a nivel
-->
de procesamiento no tanto de
-->
almacenamiento por el
-->
mismo modo vamos a hacer lo
-->
siguiente entonces vamos a ir
-->
a los job design tenemos una
-->
carpeta que se llama AXA y
-->
ahora vamos a hacer lo
-->
siguiente vamos a crear una
-->
subcarpeta eh perdón una
-->
subcarpeta aquí un folder
-->
dentro de AXA para organizarnos
-->
un poquito más que se llame
-->
procesamiento Big Data esto
-->
necesita no no acepta espacio
-->
en blanco entonces lo separo
-->
con Underscore eh la carpeta
-->
la llame Big Data Finish aquí
-->
perfecto vamos a crear entonces
-->
eh un job dentro de la carpeta
-->
Procesamiento Big Data que lo
-->
vamos a llamar Job Underscore
-->
Job Película Underscore más
-->
popular más popular por
-->
década eh Job Película más
-->
popular por década recuerde
-->
que tiene que que usar un
-->
carácter eh porque no acepta
-->
el espacio como carácter
-->
especial entonces sepárelo
-->
por un Underscore Job
-->
Película más popular por
-->
década ahora lo que vamos
-->
a hacer vamos a hacer
-->
un progresamiento yo en la
-->
parte teórica le le dije
-->
prácticamente lo que tú haces
-->
con Big Data es prácticamente
-->
lo que hacías anteriormente
-->
sin Big Data con
-->
composición nacional la única
-->
diferencia es que puede haber
-->
una variedad en los datos y
-->
segundo que quizás eh ese gran
-->
volumen de datos necesita
-->
entonces que sea progresado
-->
con Big Data por eh por algo
-->
relacionado con la parte de
-->
velocidad entonces vamos a
-->
darle aquí Finish y para
-->
rehusar un poco ya lo que
-->
hemos hecho y no tener que
-->
volver a configurar en EBS es
-->
lo mismo váyase a la carpeta
-->
y busque el último ejemplo
-->
que hicimos el día de ayer
-->
que fue eh Jot formatear
-->
archivo que realidad no lo
-->
formateamos por tiempo no
-->
lo alcanzamos a formatear
-->
Jot formatear archivo por
-->
favor lo abre y cópiese el
-->
tepreyop y el HDFC
-->
Connection lo copia para no
-->
tener nuevamente que que
-->
configurar esto y lo pega acá
-->
listo
-->
bien la idea es no tener que
-->
rehusar en EBS es lo mismo
-->
entonces pegas acá si ya
-->
cierran el archivo ese que
-->
hicimos el día de ayer para
-->
que de pronto no te cause
-->
algún tipo de confusión
-->
listo eh qué es lo que voy
-->
a hacer eh voy a mostrar
-->
inicialmente eh el archivo
-->
que lo tengo por aquí creo
-->
que sí bueno voy a mostrar
-->
este archivo que lo tengo
-->
por aquí se llama Phil
-->
actor que ya está en el en
-->
el clóster de Hadud en ese
-->
momento y lo muestro por aquí
-->
tiene hasta hacer de aquí
-->
este archivo lo que tiene
-->
es datos de los actores
-->
principales de una película
-->
entonces tiene por ejemplo el
-->
año el el tiempo de la
-->
película que está como
-->
longitud en minutos el título
-->
de la película el actor
-->
principal la actriz principal
-->
director y la popularidad
-->
entonces aquí tiene en realidad
-->
que el archivo es muy
-->
pequeño carecería de sentido
-->
a nivel pragmático en
-->
plástico a nivel de
-->
producción usar nuestro
-->
archivo para saber data
-->
porque es demasiado pequeño
-->
esto lo puedo hacer sin
-->
necesidad de big data pero
-->
eh partiendo del hecho en que
-->
tengo poco recurso pues eh al
-->
final trate de piense que
-->
este archivo es inmensamente
-->
grande o que hay un conjunto
-->
de archivos en que me toca
-->
unirlos y la cantidad del
-->
volumen es grande para la
-->
velocidad que en el cual yo
-->
quiero ejecutar o que me
-->
termine de ejecutar el
-->
proceso pero bien eh en pocas
-->
palabras yo tengo el año de
-->
la película tengo aquí la
-->
popularidad de la película y
-->
voy a sacar la película más
-->
popular por por década ¿OK?
-->
Ese es lo que voy a hacer
-->
¿Listo? Asumamos entonces que
-->
el archivo es elevadamente
-->
grande por volumen y me toca
-->
entonces progresarlo con
-->
big data para obtener
-->
digamos respuestas en tiempo
-->
real. Me devuelvo nuevamente
-->
a la al talent big data
-->
esta que está aquí. Y lo
-->
primero que voy a hacer
-->
entonces es que voy a leer
-->
el archivo que ya tengo en
-->
el clóset de jadú que lo
-->
tuvimos el día de ayer. Para
-->
leer un archivo directamente del
-->
clóset de jadú entonces usamos
-->
a T HDFS input HDFS input
-->
esto es para leer algo para
-->
que lo tenga presente
-->
cualquier componente de
-->
talent que tenga relación con
-->
la lectura o escritura de
-->
algo siempre tiene que tener
-->
un esquema una estructura
-->
hay que configurar el esquema
-->
entonces este input va a
-->
intentar leer un archivo
-->
entonces con esos procesos
-->
de lectura y escritura de
-->
archivos es necesario que
-->
tenga una un esquema o sea
-->
decir cómo es la configuración
-->
que tiene las columnas para
-->
talent no le interesa el nombre
-->
de las columnas tú puedes
-->
llamarla como tú quieras al
-->
fin y al cabo la interesa es
-->
el orden y el tipo de datos
-->
de las columnas eso es lo que
-->
le interesa al final pero yo
-->
puedo hacer un esquema y los
-->
encabezados no necesariamente
-->
tienen que coincidir con el
-->
archivo original para esto ya
-->
recordamos que para poder
-->
configurar un componente
-->
entable tiene que coger la
-->
gráfica del componente o sea
-->
el icono del componente le
-->
da doble clic y nos lleva en
-->
la perspectiva de abajo para
-->
hacer la configuración
-->
como ya tenemos una conexión
-->
existente y el día ayer te
-->
recomendé cuando deberías
-->
usar un HDFS connection cuando
-->
sepas en que en el mismo
-->
yod vas a tener varios
-->
componentes de tipo HDFS
-->
entonces lo más recomendable
-->
porque es más sencillo
-->
configurarlo es tener nada más
-->
una conexión y esa conexión la
-->
reuso n veces en el mismo yodo
-->
sería la condición ideal o
-->
digamos el caso de estudio
-->
ideal en el cual deberías
-->
usar el HDFS connection
-->
vamos a decirle entonces en la
-->
confesión del input en que
-->
vamos a usar una conexión
-->
existente
-->
y expando entonces la lista de
-->
conexiones y debería
-->
aparecer la conexión como
-->
tal acto seguido entonces
-->
voy a definir lo siguiente voy
-->
a escoger el archivo como lo
-->
con nombre el archivo tengo al
-->
final un botón
-->
que me va a permitir conectarme
-->
al
-->
al closer de hadut y voy a
-->
escoger el que se llama fil
-->
actor que ya lo habíamos
-->
definido el día de ayer
-->
fil actor
-->
perfecto ahora vamos a hacer
-->
la configuración del archivo
-->
note algo muy particular de
-->
la herramienta es que la
-->
configurando con los
-->
componentes de tipo HDFS es
-->
que la lectura específica
-->
sean archivos delimitados
-->
te preguntarás si los archivos
-->
no están delimitados
-->
entonces te tocaría hacer un
-->
formateo de esos datos para
-->
que se han leído
-->
directamente con los componentes
-->
de HDFS ya con la versión
-->
comercial tienes otros
-->
componentes que pudieras
-->
agregar
-->
listo entonces el tipo de
-->
archivo es tipo textual
-->
esta parte aquí hay un tipo
-->
que se llama sequence files
-->
ese sequence file lo voy a
-->
explicar mejor con hype
-->
pero voy a dejarlo aquí con
-->
text
-->
el separador de fila es
-->
slash n
-->
separador de campo es
-->
punto y coma así entonces
-->
tiene que coincidir estos
-->
elementos
-->
y al final el header
-->
hay un header en ese archivo
-->
entonces le coloco uno
-->
diciéndole que la primera
-->
fila son los encabezados
-->
del archivo
-->
en pocas palabras en que no la
-->
lea como les decía y debe
-->
tener estos memorias y va a
-->
trabajar con esta herramienta
-->
todas las herramientas que
-->
tienen lectura y escritura de
-->
archivo tengo que con tengo
-->
que especificar un esquema
-->
entonces puede que varíe la
-->
posición en los componentes
-->
de talent lo que sí es
-->
seguro es que vas a encontrar
-->
esto en alguna parte de esta
-->
configuración de los
-->
componentes en este caso está
-->
en la parte de arriba y
-->
veces que está en la parte del
-->
medio y otro está en la
-->
parte de abajo
-->
entonces dele clic en
-->
editar esquema y este esquema
-->
de aquí yo puedo hacerlo de
-->
forma manual
-->
creo que podía ser bueno
-->
cuando la cantidad de
-->
columnas es muy pequeña
-->
quizás dos máximo cinco
-->
pero si la cantidad de filas
-->
es muy elevada lo mejor es que
-->
haga como hicimos el día de
-->
ayer creamos una metadata
-->
con el tipo de archivo
-->
recuperamos los datos en las
-->
columnas en el orden en que
-->
está y los tipos de datos que
-->
asumió la herramienta y
-->
mejor la importo esa es la
-->
mejor forma de hacerlo
-->
entonces aquí le damos
-->
importar y el día de ayer
-->
hicimos
-->
un esquema que se llama
-->
filactor.xml
-->
dele abrir por favor
-->
y dele aquí ok
-->
se cuenta que hasta el momento
-->
lo que hemos hecho es
-->
prácticamente lo del día de
-->
ayer en el cual nos estamos
-->
conectando a un archivo
-->
ahora pasa lo siguiente
-->
voy a resolver esto
-->
cómo voy a resolver esto
-->
bueno la idea va a ser la
-->
siguiente
-->
voy a intentar
-->
voy a decirle un poco la
-->
metodología que voy a
-->
trabajar el día de hoy el día
-->
del día de mañana
-->
quizás el yoke lo voy a
-->
resolver en algunos casos de
-->
forma ineficiente
-->
porque la idea que voy a
-->
buscar es que usted pueda
-->
ver la mayor cantidad de
-->
componentes en este curso
-->
o sea entonces podamos
-->
hacer los yoke con
-->
diferentes componentes y
-->
pueda ya tener digamos
-->
un background mucho más
-->
grande de que hace cada
-->
componente en el caso del
-->
talent big data
-->
entonces miren la cual va a
-->
ser la idea que cómo voy a
-->
resolver este señor que está
-->
acá
-->
se lo voy a resolver de esta
-->
manera
-->
de otro momento
-->
listo aquí
-->
este señor me está
-->
espera un momento que
-->
resuelva aquí algo
-->
bueno mejor lo veo acá
-->
porque me tiene hay unas
-->
piezas
-->
discúlpeme un momento y se
-->
lo muestro mejor acá
-->
por favor
-->
entonces
-->
por ejemplo lo siguiente
-->
en que yo tengo
-->
el año de la película
-->
noventa noventa noventa
-->
noventa y uno noventa y
-->
dos noventa y tres noventa
-->
y cuatro
-->
entonces lo que voy a hacer
-->
es lo siguiente voy a
-->
convertir el año en
-->
década
-->
en pocas palabras este
-->
año que está aquí noventa
-->
y uno lo voy a convertir
-->
en noventa
-->
porque a mí me interesa es
-->
la película
-->
más popular por década
-->
entonces los años los voy
-->
a convertir en década
-->
y ya después que convierta
-->
los años en década
-->
hago una agrupación
-->
y en esa agrupación
-->
entonces saco los
-->
diferentes elementos
-->
ok eso es lo que voy a
-->
hacer esa es la idea que
-->
voy a entonces
-->
listo ahora voy a hacer
-->
lo siguiente
-->
voy a usar un componente
-->
que es muy popular en
-->
talent
-->
que se utiliza mucho para
-->
mapear o para cambiar el
-->
formato de los datos
-->
en este caso voy a usar
-->
entonces el
-->
tema
-->
y voy inicialmente
-->
para hacer un
-->
testeo
-->
voy a colocar aquí un
-->
telocrow
-->
para testear el resultado
-->
que me va a dar
-->
listo entonces
-->
el telocrow
-->
voy a agregar otro
-->
componente que es
-->
fundamental
-->
que es un componente
-->
para agrupar datos
-->
voy a hacer entonces
-->
aquí un
-->
telocrow
-->
se llama
-->
telocrow
-->
telocrow
-->
y voy a usar otro
-->
componente que se llama
-->
telocrow
-->
componente muy
-->
utilizado en talent
-->
en este orden
-->
y voy a decirle
-->
la idea como tal
-->
aclaro que la idea
-->
fundamental es
-->
que haga yo
-->
que agregar un componente
-->
nuevo
-->
quizás
-->
esa no es la forma más
-->
eficiente pero
-->
aprovecho esta forma
-->
para agregar
-->
el test short
-->
y el
-->
telocrow
-->
entonces son
-->
cuantos componentes
-->
he agregado
-->
uno, dos, tres, cuatro, cinco
-->
componentes
-->
el input
-->
el temap
-->
el test shortrow
-->
el telocrow
-->
y el
-->
telocrow
-->
el telocrow
-->
ya saben que
-->
hay algunos
-->
componentes en talent
-->
que no están
-->
instalados
-->
básicamente
-->
técnicamente que es
-->
en el caso de java
-->
como este está
-->
basado en java
-->
es descargar un
-->
punto YAR
-->
que es el que tiene
-->
la codificación
-->
de ese componente
-->
primero entonces
-->
aquí
-->
hay dos
-->
corrientes
-->
de personas
-->
elige cual va a ser
-->
la forma en que
-->
tu quieres trabajar
-->
una forma es
-->
la que hice
-->
ahora mismo es que
-->
yo tengo todos
-->
los componentes
-->
agrego todos los componentes
-->
de java
-->
los conecto
-->
y después los
-->
configuro
-->
hay personas que
-->
no le gusta
-->
trabajar así
-->
hay personas que
-->
van agregando
-->
componentes
-->
según lo que van
-->
requiriendo
-->
al fin
-->
adaptate como
-->
tú
-->
digamos como
-->
mejor crees tú
-->
que
-->
trabajes más rápido
-->
en este caso
-->
voy a conectar
-->
entonces
-->
el HDFS input
-->
con
-->
el temap
-->
el temap
-->
y lo conecto
-->
con el
-->
techo row
-->
y voy a
-->
colocar aquí
-->
como salida
-->
ordenar
-->
registros
-->
voy a conectar
-->
el techo row
-->
con el
-->
T-aggregated
-->
e inicialmente
-->
voy a mandar
-->
el T-aggregated row
-->
al
-->
techo
-->
log row
-->
este techo lo voy a
-->
tener ahí
-->
inicialmente
-->
solamente
-->
es para
-->
para
-->
comprobar
-->
antes de
-->
finalizar
-->
el job
-->
completo
-->
voy a
-->
comprobar
-->
que lo que quiero
-->
hacer
-->
es lo que me
-->
está dando el job
-->
recordamos
-->
como tip
-->
entonces
-->
que
-->
ese punto
-->
rojo que
-->
tenemos ahí
-->
en el
-->
temap
-->
o en
-->
cualquier
-->
componente
-->
que tenga
-->
detalle
-->
y te
-->
hace
-->
falta una
-->
configuración
-->
ahí
-->
bien
-->
entonces
-->
veamos
-->
vamos a
-->
configurar
-->
inicialmente
-->
el tema
-->
recuerda que
-->
como
-->
como
-->
buena
-->
práctica
-->
te
-->
recomiendo
-->
en que
-->
no dejes
-->
estas
-->
conexiones
-->
con
-->
nombres
-->
genéricos
-->
row 1
-->
row 2
-->
solamente
-->
la voy a
-->
cambiar
-->
a ese row 1
-->
dale click
-->
primero en
-->
un row 1
-->
y después
-->
otra vez click
-->
y lo más
-->
recomendable
-->
es que
-->
le des
-->
el nombre
-->
de la
-->
de la
-->
entrada
-->
en este caso
-->
como el
-->
archivo se llama
-->
fill actor
-->
voy a
-->
cambiar ese row a
-->
fill
-->
on the record actor
-->
eso no
-->
más lo voy a
-->
hacer aquí
-->
para recordar
-->
de ayer
-->
lo demás
-->
no lo
-->
voy a hacer
-->
para evitar
-->
veníamos
-->
para
-->
no
-->
consumir
-->
tanto tiempo
-->
vamos entonces
-->
aquí ahora
-->
a configurar
-->
el tema
-->
nota
-->
entonces
-->
que
-->
aquí
-->
aparece
-->
fill actor
-->
que fue
-->
el nombre
-->
de la
-->
entrada
-->
recuerda que
-->
cambia row 1
-->
a fill actor
-->
entonces
-->
esto que
-->
está acá
-->
arriba
-->
tiene
-->
el nombre
-->
de la entrada
-->
por eso es que
-->
es más recomendable
-->
que le des
-->
el nombre
-->
allá
-->
para que
-->
puedas
-->
guiarte mejor
-->
aquí en el
-->
tema
-->
y más cuando
-->
vayas a hacer
-->
un joy
-->
a nivel
-->
de TL
-->
listo
-->
nota lo siguiente
-->
ahora
-->
estos archivos
-->
estas columnas
-->
que están
-->
aquí
-->
corresponden a
-->
las columnas
-->
de la entrada
-->
del input
-->
recordar
-->
aquel input
-->
hicimos
-->
un esquema
-->
e importamos
-->
los diferentes
-->
columnas
-->
que va a tener
-->
y acá también
-->
coincide los tipos
-->
de datos
-->
tú puedes cambiar
-->
los tipos
-->
de datos
-->
si tú quieres acá
-->
pero tienes que
-->
tener muy
-->
pendiente
-->
que de pronto
-->
puede haber
-->
unas
-->
conversiones
-->
en que
-->
el lenguaje
-->
ya no las
-->
permita
-->
por ejemplo
-->
si yo
-->
intentara
-->
no la gusta
-->
ya por favor
-->
si yo intentara
-->
cambiar este
-->
de integer
-->
a string
-->
aquí va a ver
-->
un error
-->
¿por qué?
-->
porque el
-->
dato viene
-->
de tipo integer
-->
de la entrada
-->
y cuando
-->
llega aquí
-->
lo intenta convertir
-->
a string
-->
y esa
-->
esa conversión
-->
no la puede hacer
-->
directamente
-->
entonces
-->
sí puedes cambiar
-->
los tipos
-->
de datos
-->
pero tienes que
-->
estar muy
-->
pendiente
-->
en cómo
-->
vas a convertir
-->
esos tipos
-->
de datos
-->
¿ok?
-->
no voy a hacer
-->
tanto ejemplo
-->
con esto porque
-->
lo principal
-->
aquí es
-->
big data
-->
esto normalmente
-->
venía de un curso
-->
de tres días
-->
que se llamaba
-->
talent data integration
-->
donde usted
-->
aprendía esta
-->
parte pero
-->
no me puedo
-->
demorar mucho
-->
en ciertos
-->
detallitos
-->
aquí
-->
normalmente
-->
¿cómo
-->
hace para mapear
-->
datos
-->
en esta herramienta
-->
para mapear
-->
datos entonces
-->
aquí tengo
-->
el dato de entrada
-->
y para mapear
-->
el dato
-->
lo más recomendable
-->
es que hagas
-->
lo siguiente
-->
que definas
-->
una variable
-->
intermedia
-->
entonces
-->
dale click
-->
aquí
-->
en variable
-->
en el más
-->
este que está ahí
-->
aquí te pide
-->
un tipo
-->
de datos
-->
y en este
-->
caso quiero que
-->
el tipo de
-->
datos de
-->
salida
-->
sea un entero
-->
entonces
-->
voy a cambiar
-->
esto a entero
-->
a integer
-->
y nota que
-->
del lado
-->
siguiente
-->
o sea la columna
-->
siguiente al table
-->
que tienes
-->
te está el nombre
-->
la variable
-->
esta variable
-->
la voy a llamar
-->
década
-->
solamente
-->
como
-->
elemento
-->
informativo
-->
nota que
-->
al ladito
-->
de la variable
-->
vas a tener un
-->
check box
-->
cierto
-->
si
-->
ese check box
-->
está habilitado
-->
nota que
-->
te cambia
-->
el tipo de datos
-->
de int
-->
a integer
-->
me explico
-->
lo que pasa
-->
es que int
-->
es lo que llaman
-->
un tipo de datos
-->
simple en java
-->
e integer
-->
es un tipo
-->
de datos
-->
object
-->
en pocas palabras
-->
en palabras llanas
-->
y castas
-->
para que sirve eso
-->
si la expresión
-->
te va a
-->
volver un nulo
-->
tienes que
-->
definirlo
-->
como queto
-->
o sea como integer
-->
o sea tienes que
-->
estar chuleado
-->
si sabes
-->
que la expresión
-->
no te devuelve
-->
integer siempre
-->
te devuelve un valor
-->
entonces lo dejas
-->
de tipo simple
-->
o sea
-->
sin chulearlo
-->
porque hay un error
-->
si lo
-->
si por ejemplo
-->
si tienes tipo simple
-->
así como está
-->
inicialmente
-->
sin el chulito
-->
y te devuelva a nulo
-->
que sale un error
-->
de ejecución
-->
porque los tipos
-->
simples en java
-->
siempre tienen que
-->
tener un valor
-->
esto no es de talent
-->
esto es necesariamente
-->
de java
-->
listo entonces
-->
aquí hay varias formas
-->
de hacer lo mismo
-->
voy a empezar con una
-->
quiero tomar
-->
ese campo que se llama
-->
gear
-->
y pasarlo y hacer
-->
una operación
-->
para convertirlo en una década
-->
entonces
-->
voy a tomar esta columna
-->
que se llama gear
-->
y la voy a soltar
-->
aquí donde dice expression
-->
para que sea más sencillo
-->
cuando colocas
-->
el mouse
-->
en la expresión
-->
dale click aquí
-->
y se te va a habilitar
-->
un botoncito
-->
que te va a abrir
-->
un texaria
-->
de configuración
-->
dale click
-->
ahí en ese botón
-->
por favor
-->
para que te aparezca
-->
un texario
-->
eso mismo que hice
-->
de tomar ese gear
-->
y pasarlo a este lado
-->
lo hubiese hecho
-->
también igual
-->
no lo haga
-->
para que lo tenga usted
-->
allá nada más
-->
para que no tenga que hacer
-->
dos cosas
-->
es
-->
abro la expresión
-->
vacía
-->
y aquí me aparecen
-->
todas las columnas
-->
de entrada que están
-->
de este lado
-->
tanto si yo pude
-->
también haber hecho esto
-->
darle doble click
-->
y me hubiese hecho
-->
exactamente lo mismo
-->
ok
-->
ahora nota que
-->
en la parte de aquí abajo
-->
te aparecen
-->
una parte de funciones
-->
estas funciones
-->
estas funciones
-->
que te aparecen
-->
de este lado
-->
no cierre solamente
-->
mira mi pantalla
-->
esas funciones
-->
que te aparecen
-->
de ese lado
-->
son las mismas funciones
-->
que te
-->
que has agregado
-->
en esta sesión
-->
que hice code
-->
en esta sesión
-->
code
-->
donde están unos códigos
-->
hechos netamente
-->
en java
-->
esta que está
-->
no la está
-->
mira lo de este lado
-->
son las funciones
-->
que te aparecen allá
-->
entonces tú puedes agregar
-->
nuevas funciones
-->
tú las codificas
-->
nuevas funciones
-->
y las puedes re-usar
-->
n veces
-->
en los proyectos
-->
que tengo
-->
mi recomendación
-->
yo nunca lo he hecho
-->
mi recomendación es
-->
si sabes que vas a crear
-->
una función
-->
en que la vas a re-usar
-->
en njobs
-->
sería bueno que la codifiques
-->
pero si la vas a usar
-->
un solo joc
-->
haz el código
-->
en algo que te voy a mostrar
-->
más adelante
-->
haz el código
-->
en un componente
-->
que se llama te-java
-->
y listo
-->
lo pones el código ahí
-->
pero creo que
-->
desgastarse
-->
en subir esto acá
-->
colocarlo en el formato
-->
que lo especifica tal
-->
creo que es
-->
mucho trabajo
-->
para algo que de pronto
-->
vas a usar solamente
-->
un solo joc
-->
listo
-->
me devuelvo entonces
-->
nuevamente
-->
era solamente informativo
-->
esa parte aquí
-->
y voy a convertir
-->
este año
-->
voy a convertir
-->
este año
-->
entonces
-->
en una década
-->
para hacer esto
-->
esto es netamente java
-->
hago lo siguiente
-->
divido entre 10
-->
y multiplico por 10
-->
ya le explico entonces
-->
divido entre 10
-->
y multiplico por 10
-->
explico de forma sencilla
-->
que fue lo que hice ahí
-->
y esto al final
-->
termina siendo
-->
netamente algo
-->
particular de java
-->
entonces
-->
pasa lo siguiente
-->
supongamos que tú tengas
-->
este número integer
-->
giar
-->
igual a 1991
-->
si yo por ejemplo
-->
digo
-->
giar
-->
entre 10
-->
si el dato
-->
este es entero
-->
notará lo siguiente
-->
que giar entre 10
-->
daría
-->
1999,1
-->
verdad
-->
pero como el dato
-->
es entero
-->
entonces la división
-->
de dos entero
-->
en java
-->
da en otro entero
-->
por lo tanto
-->
esta parte real se quita
-->
y me daría
-->
199
-->
1999
-->
si lo multiplico
-->
por 10
-->
convierto el año
-->
91
-->
en 1990
-->
que es la década
-->
que quiero
-->
ahora
-->
si el dato
-->
es un doble
-->
en java
-->
por ejemplo
-->
doble
-->
voy a copiar esto
-->
así
-->
doble
-->
y este dato
-->
doble
-->
o sea real
-->
o float
-->
como tú quieras
-->
en data
-->
en java
-->
y datos reales
-->
sería float y doble
-->
si yo hago esto
-->
esto me daría
-->
si me estaría dando
-->
esto si me está dando
-->
esta parte
-->
entonces ahí
-->
porque me está resolviendo
-->
el problema
-->
porque el dato es entero
-->
si el dato fuera doble
-->
o float
-->
no me daría
-->
lo que yo quiero
-->
entonces
-->
aquí tengo
-->
divido entre 10
-->
y multiplico por 10
-->
ok
-->
vamos a pasar unos datos
-->
de aquí
-->
para acá
-->
el caso
-->
no recuerdo el nombre
-->
ayer que se
-->
el día de ayer
-->
alguien se le
-->
todos los colunas
-->
se le colocaron
-->
una sola
-->
entonces yo te recomiendo
-->
que expandas esto
-->
un poco
-->
verticalmente
-->
para que tengas espacio
-->
y vamos a soltar
-->
de este lado
-->
década
-->
y vamos a soltar
-->
entonces
-->
década
-->
title
-->
y popularidad
-->
que son los tres campos
-->
que necesito
-->
para resolver
-->
el problema
-->
de la película
-->
más popular
-->
por década
-->
si
-->
la fusión
-->
esta
-->
es indistinto
-->
en este caso
-->
en particular
-->
te explico
-->
porque en este caso
-->
el paréntesis
-->
y el por
-->
tienen
-->
la misma
-->
precedencia
-->
entonces
-->
se evalúa
-->
de izquierda a derecha
-->
o sea aquí
-->
evaluaría como el
-->
perdón
-->
el entre
-->
y el por tiene
-->
la misma precedencia
-->
entonces evalúa
-->
de izquierda a derecha
-->
pero fíjate algo
-->
con lo que tú me estás
-->
mencionando
-->
si yo tengo
-->
esto así
-->
por ejemplo
-->
tengo ahora
-->
GR
-->
tengo esto
-->
actualmente así
-->
si yo tengo
-->
este más aquí
-->
el por
-->
tiene más
-->
precedencia entonces aquí
-->
multiplicaría
-->
y después sumaría
-->
entonces aquí
-->
si tú quieres sumar
-->
aquí si es necesario
-->
esto así
-->
porque el por
-->
y el tiene más
-->
precedencia
-->
para el caso
-->
en particular
-->
pues no
-->
daría lo mismo
-->
si le coloco el paréntesis
-->
gracias a ti
-->
por preguntar
-->
fíjate que
-->
mientras
-->
algunos
-->
terminan aquí
-->
el caso
-->
del
-->
el caso
-->
del hijo mío
-->
cuando estaba
-->
en primaria
-->
entonces el
-->
profesor le coloco
-->
una expresión
-->
de esta
-->
donde tenía un más
-->
y un menos
-->
y un por
-->
y entonces
-->
el profesor
-->
sumaba
-->
primero restaba
-->
y después multiplicaba
-->
no hay paréntesis
-->
entonces
-->
yo le estaba
-->
yo le ayudaba
-->
a mi hijo a resolver
-->
los problemas
-->
y
-->
perdió esa
-->
evaluación
-->
y entonces me tocó bien
-->
de profesor
-->
mira qué pena
-->
lo que pasa es que hay
-->
una precedencia de
-->
operadores
-->
pero eso va más que todo
-->
para la gente de
-->
sistema
-->
la gente pronto
-->
no le presta mucha
-->
atención a eso
-->
pero bueno
-->
entonces
-->
aquí tenemos
-->
esta parte
-->
ok
-->
listo
-->
yes
-->
me dice
-->
retomo
-->
la idea entonces
-->
al final
-->
de que quiero
-->
resolver
-->
al final me va a quedar
-->
más o menos
-->
esto
-->
mire
-->
lo siguiente
-->
ahora
-->
voy a tomar
-->
estos datos
-->
aquí
-->
me va a quedar
-->
vamos a poner que
-->
este ya era
-->
noventa y uno
-->
me va a quedar todo
-->
en noventa
-->
ahora lo que quiero hacer
-->
es lo siguiente
-->
voy a
-->
ordenar
-->
por década
-->
voy a
-->
ordenar
-->
por década
-->
ya les
-->
voy a hacer lo siguiente
-->
ahora
-->
voy a ordenar
-->
los datos
-->
una particularidad
-->
que se tiene
-->
con los
-->
componentes
-->
de talent
-->
es que
-->
cuando hay
-->
un esquema
-->
de entrada
-->
el esquema
-->
cuando hay un
-->
esquema
-->
de entrada
-->
y de
-->
salida
-->
en este
-->
caso
-->
tema que es
-->
un esquema
-->
de entrada
-->
y de salida
-->
la
-->
salida
-->
automáticamente
-->
y esto me va
-->
a llegar
-->
acá como
-->
entrada
-->
en el
-->
entonces
-->
haga lo
-->
siguiente
-->
vaya al
-->
y note ve que
-->
aquí tiene
-->
editar
-->
esquema
-->
entonces como
-->
este tiene
-->
que trabajar
-->
con
-->
datos
-->
la posición
-->
te va a
-->
cambiar
-->
pero al final
-->
te va a dar
-->
lo mismo
-->
entonces
-->
si das
-->
clic aquí
-->
en editar
-->
esquema
-->
darte
-->
cuenta que
-->
aquí
-->
esta es lo que
-->
esta es la
-->
salida
-->
la entrada que me está
-->
llegando
-->
del tema
-->
y esta es la
-->
entrada que
-->
tengo
-->
del techo
-->
esto es poco para
-->
perdón
-->
esta es la
-->
salida del
-->
tema
-->
y esta es la
-->
entrada del
-->
techo
-->
aquí tú puedes
-->
agregar
-->
y quitar
-->
lo que tú
-->
quieras
-->
en caso
-->
de que
-->
pasa
-->
pasa
-->
y que es
-->
lástima que no le hago
-->
un ejemplo para
-->
cada cosa
-->
siempre tengo que
-->
invertirle
-->
pasa en que de
-->
pronto
-->
suponte que aquí
-->
no te
-->
llegó
-->
es muy raro que
-->
pase esto
-->
que de pronto
-->
tenga aquí
-->
una salida
-->
y que si
-->
se hace
-->
con esta
-->
entrada acá
-->
entonces tú
-->
le puedes
-->
dar aquí
-->
sincronizar
-->
columnas
-->
y lo que
-->
hace eso
-->
es que
-->
se puede
-->
pasar pero eso
-->
para eso es
-->
sincronizar
-->
columnas
-->
entonces vamos
-->
a configurar
-->
el techo
-->
row
-->
y el techo
-->
row quiero que
-->
haga
-->
lo siguiente
-->
dele aquí
-->
un más
-->
y este más
-->
entonces
-->
te coloca
-->
las
-->
columnas que
-->
tiene
-->
entrada en este caso
-->
quiero primero
-->
por década
-->
y aquí
-->
tiene que
-->
estar muy
-->
pendiente con
-->
el tipo
-->
de
-->
datos
-->
que vas a
-->
ordenar
-->
década es integer
-->
por lo tanto es
-->
numérico
-->
y aquí puedes
-->
ordenar
-->
ascendente o
-->
descendente
-->
para el caso
-->
particular
-->
me da lo
-->
mismo si es
-->
ascendente
-->
o
-->
descendente
-->
vamos ahora
-->
a hacer
-->
un nuevo
-->
criterio
-->
de ordenamiento
-->
y aquí
-->
voy a
-->
ordenar
-->
ahora por
-->
popularidad
-->
popularidad
-->
también te
-->
recomendé
-->
como esto es un
-->
table
-->
en java
-->
java tiene un
-->
pequeño box
-->
que no ha podido
-->
corregir que a veces
-->
yo muevo con el
-->
mouse y no me
-->
actualiza
-->
cuando tengas un
-->
table acostumbre
-->
darle enter
-->
darle enter
-->
para que tome
-->
el cambio
-->
y quiero que este
-->
señor me
-->
ordene
-->
descendentemente
-->
entonces retomo
-->
nuevamente la
-->
idea mejor acá
-->
en un nuevo
-->
archivo
-->
nuevo aquí
-->
tengo
-->
década
-->
tengo
-->
title
-->
y tengo
-->
popularidad
-->
suponte que
-->
tengas aquí
-->
mil novecientos
-->
noventa
-->
título x
-->
y popularidad
-->
por ejemplo
-->
ochenta
-->
tienes mil
-->
novecientos
-->
noventa también
-->
popularidad
-->
noventa y uno
-->
quizás
-->
tengas dos mil
-->
aquí
-->
popularidad
-->
ochenta y siete
-->
y
-->
tengas
-->
mil
-->
novecientos
-->
noventa
-->
popularidad
-->
y
-->
seta
-->
aquí
-->
noventa y dos
-->
al ordenar primero
-->
por década
-->
me quedarían los
-->
datos al final
-->
de esta
-->
manera
-->
me quedaría
-->
todas las
-->
décadas
-->
primero
-->
ordeno
-->
por década
-->
y después por
-->
popularidad
-->
descendentemente
-->
significa que
-->
el primer
-->
registro
-->
que va a
-->
tener es
-->
el
-->
la mayor
-->
popularidad
-->
que sería
-->
noventa y dos
-->
o sea me
-->
quedaría más o menos
-->
esto de esta
-->
manera
-->
noventa y dos
-->
después seguiría
-->
de esta
-->
manera
-->
noventa y uno
-->
después seguiría
-->
ochenta
-->
y después
-->
seguiría
-->
este
-->
dos mil que está aquí
-->
si me entiende cuál es la
-->
idea
-->
al final
-->
lo que quiero
-->
es que
-->
me quede
-->
en el primera
-->
fila de cada
-->
grupo
-->
me quede el que tenga
-->
la película que tenga
-->
mayor popularidad
-->
eso fue lo que hice
-->
listo
-->
esta es la idea
-->
que me va a quedar así
-->
ahora mire lo que voy
-->
a hacer
-->
voy aquí al
-->
T aggregated row
-->
y esto lo que hace
-->
es un group by
-->
hago la
-->
semejanza porque de
-->
pronto con el group by
-->
sale más fácil de
-->
entender
-->
en un group by
-->
tú tienes
-->
un select
-->
tienes un from
-->
y tienes un group by
-->
entonces
-->
esta parte
-->
de group by
-->
tienes acá
-->
group by como tal
-->
la función group by
-->
vamos a
-->
configurarlo entonces
-->
voy a
-->
hacer lo siguiente
-->
voy a agrupar
-->
por década
-->
o sea voy a
-->
hacer más o menos
-->
la sentencia de esta
-->
group by
-->
década
-->
cómo se hace esto
-->
con la
-->
con la
-->
con la herramienta
-->
vete la
-->
herramienta un momento
-->
vamos a configurar
-->
el T aggregated row
-->
y este
-->
agrupar
-->
por
-->
indica
-->
el group by
-->
entonces
-->
dale aquí
-->
más
-->
y date
-->
cuenta lo siguiente
-->
que aquí
-->
no me hace
-->
automáticamente
-->
el
-->
la
-->
circulación entonces
-->
vete aquí a
-->
editar esquema
-->
por favor
-->
y de editar
-->
esquema
-->
necesito
-->
lo siguiente
-->
necesito
-->
década
-->
necesito
-->
title
-->
y también
-->
necesito
-->
la propiedad
-->
los tres campos
-->
necesito
-->
le das
-->
ok por
-->
favor
-->
y ahora
-->
si te va a
-->
permitir
-->
definir
-->
dale aquí
-->
más
-->
y aquí
-->
tú eliges
-->
la columna
-->
aquí tienes
-->
la columna de entrada
-->
la columna de
-->
salida cómo quieres
-->
llamarla
-->
con respecto a la
-->
columna de
-->
entrada
-->
y ahora presta
-->
atención a lo siguiente
-->
esta función
-->
esta operación
-->
acá
-->
indicaría
-->
lo que vas a
-->
colocar la
-->
función de
-->
grupo en el
-->
SELEC
-->
recordará que
-->
las
-->
funciones de
-->
grupo que tú has
-->
manejado a
-->
nivel de SQL son
-->
con min
-->
max
-->
a promedio
-->
que es
-->
AVG
-->
se me
-->
escapa
-->
zoom
-->
etcétera
-->
entonces
-->
este señor
-->
viene con
-->
algunas en
-->
particular
-->
en primer
-->
lugar
-->
yo quiero
-->
sacar
-->
la máxima
-->
popularidad
-->
de la década
-->
o sea
-->
max
-->
popularidad
-->
si yo
-->
agrupo
-->
por década
-->
esta que está aquí por
-->
ejemplo
-->
este sería un
-->
grupo verdad
-->
1990
-->
si te das
-->
cuenta al sacar el
-->
máximo me da
-->
cuánto
-->
92 si vamos bien
-->
hasta ahí
-->
espero que me
-->
entienda un poquito
-->
la idea
-->
significa entonces
-->
lo siguiente ahora
-->
en que
-->
como columna
-->
de
-->
salida entonces
-->
voy aquí
-->
a cambiar esta
-->
columna
-->
y voy a
-->
definir que esta
-->
es popularidad
-->
de popularidad
-->
especifico la
-->
función de
-->
este grupo
-->
que yo quiero
-->
que en este caso
-->
va a ser el
-->
max
-->
y
-->
especifico
-->
esta es la
-->
columna el nombre
-->
la columna de
-->
salida
-->
y esta que
-->
salida
-->
la voy a mapear
-->
con la entrada
-->
que se llama popularidad
-->
ese ignore null
-->
que está ahí
-->
hay algo
-->
muy particular
-->
cuando
-->
las
-->
funciones
-->
son de
-->
suma
-->
y encuentra
-->
un nulo
-->
él sale
-->
error
-->
entonces
-->
tú dirás
-->
pero
-->
entonces
-->
si hay error
-->
mejor siempre
-->
coloca ignore null
-->
no necesariamente
-->
porque
-->
si tú colocas ignore null
-->
quizás
-->
no te puedes dar
-->
cuenta de un error
-->
de datos
-->
en que
-->
tú supones
-->
que esos datos
-->
no venga en
-->
nulos
-->
entonces si le das ignore null
-->
te viene un nulo
-->
y tú te das cuenta
-->
mejor dejar
-->
y que dispare
-->
el error
-->
y tú te das cuenta
-->
y puedes
-->
mandar
-->
de pronto
-->
esos
-->
calidad de datos
-->
y que te digan
-->
epa
-->
hubo un error
-->
eso de ese
-->
dato no puede
-->
estar nulo
-->
el joke
-->
mío no funcionó
-->
porque ese
-->
dato
-->
no tiene que estar
-->
nulo
-->
tienes que
-->
revisar
-->
entonces
-->
hay que
-->
estar muy
-->
pendiente
-->
en cómo
-->
lo vas a
-->
manejar
-->
yo diría
-->
que si tú sabes
-->
que
-->
siempre
-->
es no nulo
-->
mejor coloca
-->
déjalo así
-->
no que lo ignore
-->
de tal forma de que
-->
si hay un error
-->
te levantes el error
-->
y tú lo puedas
-->
corregir
-->
listo
-->
voy a hacer ahora
-->
lo siguiente
-->
voy a dar aquí
-->
un más
-->
y me aparece
-->
title
-->
y aquí en la
-->
función de
-->
grupo
-->
voy a
-->
usar algo
-->
que
-->
no aparece
-->
solamente
-->
hasta
-->
versión
-->
bueno eso nada más
-->
MySQL lo hace
-->
porque aquí
-->
hay un estándar
-->
de SQL
-->
que no lo permite
-->
pero este señor
-->
sí me permite
-->
hacer lo siguiente
-->
date cuenta
-->
que aquí
-->
hay una función
-->
que se llama
-->
first
-->
sácame
-->
el primer
-->
title
-->
first
-->
te explico ahora
-->
entonces
-->
que significa
-->
significa
-->
lo siguiente
-->
recordarás
-->
entonces
-->
en que
-->
si yo tengo
-->
una función
-->
de grupo a nivel
-->
de SQL
-->
yo no puedo
-->
colocar
-->
ninguna columna
-->
que no sea
-->
función de
-->
grupo
-->
me explico
-->
de esta manera
-->
si yo intento
-->
colocar en ese
-->
SQL este
-->
title
-->
que es lo que
-->
hace
-->
sale un error
-->
porque
-->
porque no es
-->
función de
-->
grupo
-->
y porque
-->
sale un
-->
error
-->
porque está
-->
diciendo
-->
si está
-->
buscando el
-->
máximo
-->
significa que
-->
el máximo
-->
es uno
-->
solo
-->
independiente
-->
que haya varios
-->
registros que
-->
tengan el máximo
-->
el máximo
-->
sigue siendo
-->
uno
-->
solo
-->
pero entonces
-->
si el
-->
grupo está
-->
formado
-->
por tres
-->
registros
-->
y solamente
-->
te puedo
-->
mostrar uno
-->
cual
-->
title
-->
quiere que
-->
te muestre
-->
entonces
-->
para evitar
-->
esa confusión
-->
SQL
-->
te manda
-->
un error
-->
cuando no
-->
colocas una
-->
función
-->
cuando la
-->
la coluna no está
-->
dentro de una
-->
función de
-->
grupo
-->
casos diferentes
-->
como MySQL
-->
que es un poco
-->
más rebelde
-->
con las
-->
estándares de
-->
SQL
-->
y MySQL
-->
no se complica
-->
la vida
-->
MySQL entonces
-->
tu puedes
-->
colocar este
-->
title
-->
y MySQL lo que
-->
hace es que
-->
a partir
-->
del grupo
-->
que tenga
-->
formado
-->
saco el primer
-->
fila
-->
ya yo sé que la
-->
primera fila
-->
va a correr
-->
como está ordenado
-->
de mayor a menor
-->
yo sé que la
-->
primera fila
-->
que está aquí
-->
va a corresponder
-->
al nombre de la
-->
película con la
-->
menor popularidad
-->
entonces
-->
lo resolví
-->
de esta manera
-->
para agregar
-->
el te short
-->
y el te
-->
aggregate row
-->
listo
-->
entonces
-->
aquí
-->
no hago
-->
más nada
-->
perfecto
-->
entonces
-->
antes de
-->
ejecutarlo
-->
te voy a
-->
explicar
-->
dónde es que
-->
entra el
-->
Big Data
-->
en el caso
-->
particular de la
-->
herramienta
-->
el procedimiento
-->
de Big Data
-->
lo está
-->
derivando
-->
en dos
-->
elementos
-->
o lo
-->
hace con
-->
MacReduce
-->
que prácticamente
-->
MacReduce
-->
quedó
-->
simplemente
-->
para
-->
aplicaciones
-->
relegadas
-->
a Hadoop
-->
decíamos
-->
ya funcionan
-->
con Hadoop
-->
para que
-->
MacReduce
-->
para que lo vas a
-->
cambiar
-->
te funciona
-->
perfectamente
-->
o lo
-->
utilizas
-->
Spark
-->
entonces
-->
la
-->
herramienta
-->
se deriva en esos
-->
dos
-->
o lo
-->
hace con
-->
MacReduce
-->
o lo
-->
hace con Spark
-->
cuando
-->
hace con
-->
MacReduce
-->
entonces
-->
que hace
-->
la herramienta
-->
como has
-->
usado
-->
una
-->
entrada que es
-->
HDFS
-->
la herramienta
-->
lo que va a hacer es lo siguiente
-->
todo lo que conecte
-->
después
-->
de aquí
-->
hacia adelante
-->
esto lo va a convertir
-->
en un código
-->
Java
-->
pero ese código Java
-->
lo va a
-->
convertir a
-->
MacReduce
-->
o sea
-->
MacReduce
-->
para distribuir
-->
toda esta parte
-->
sobre el cluster
-->
que tiene
-->
sobre Hadoop
-->
entonces ya tú no tienes que
-->
programar en
-->
MacReduce
-->
¿por qué?
-->
porque él sabe que a
-->
partir de esta entrada
-->
es lo que va a
-->
hacer entonces que
-->
todo este código
-->
lo va a convertir
-->
en MacReduce
-->
y lo va a
-->
ejecutar con
-->
Tcluster
-->
entonces ya te
-->
despreocupa
-->
si yo no tuviese
-->
esta entrada aquí
-->
si no yo hubiese
-->
leído el archivo
-->
con
-->
TfileInput
-->
de
-->
por ejemplo
-->
este
-->
TfileInput
-->
de Limite
-->
y lo conecto
-->
con este tema
-->
que está aquí
-->
ahí me puede dar
-->
el mismo resultado
-->
pero ya no estoy
-->
ejecutándolo con
-->
MacReduce
-->
entonces ahí es donde
-->
entra la herramienta
-->
con la
-->
Big Data
-->
ahora con el caso
-->
de Spark es
-->
mucho más sencillo
-->
porque Spark
-->
tú puedes
-->
no tener la
-->
entrada con
-->
HDFS
-->
sino con el TfileInput
-->
por ejemplo
-->
y aquí hay unos
-->
elementos de
-->
configuración
-->
que lo vas a
-->
encontrar acá
-->
bajito
-->
y tú le das
-->
chulea y se
-->
conviértame ese código
-->
a Spark
-->
entonces toma ese código
-->
y lo convierte
-->
Spark basado con Java
-->
y lo ejecuta
-->
con Tcluster de
-->
Spark que tengas tú
-->
ese es
-->
la ventaja
-->
de la herramienta
-->
entonces tú terminas
-->
al final
-->
usando una herramienta
-->
ETL
-->
que la herramienta
-->
toma ese ETL
-->
el código
-->
que al final
-->
lo convierte en Java
-->
y lo manda
-->
o a MacReduce
-->
o la manda a Spark
-->
dependiendo de tu configuración
-->
como la tengas
-->
ese es
-->
prácticamente
-->
el boon de la herramienta
-->
que te evita
-->
escribir el código
-->
en MacReduce
-->
o en Spark
-->
automáticamente lo hace
-->
listo entonces
-->
eso es
-->
la esencia
-->
de la herramienta
-->
a nivel de Big Data
-->
al final
-->
date cuenta que
-->
en resumida cuenta
-->
sería
-->
la misma herramienta
-->
ETL
-->
pero me ofrece
-->
la característica
-->
de convertir
-->
el código Java
-->
para que sea ejecutado
-->
con MacReduce
-->
o con una Spark
-->
esa es la esencia
-->
del Big Data
-->
sobre esta herramienta
-->
pues
-->
ahora que vamos a hacer
-->
entonces
-->
vamos a
-->
ejecutar
-->
este señor de aquí
-->
vamos a darle aquí
-->
verifica por favor
-->
en que
-->
el
-->
el yo que vayas a
-->
ejecutar
-->
corresponda
-->
al
-->
yo que deseas
-->
en este caso
-->
yo película
-->
más popular
-->
voy a
-->
ejecutar aquí
-->
bueno
-->
voy a
-->
ejecutar
-->
a ver qué
-->
sale
-->
el yo
-->
puede que sea
-->
lento
-->
pues
-->
no tengo
-->
gran
-->
cantidad
-->
porque
-->
la máquina
-->
virtual de Hyper-V
-->
tiene poca
-->
memoria
-->
pues
-->
en un ambiente
-->
real
-->
vas a tener un
-->
clúster
-->
con varios
-->
equipos
-->
o varias
-->
o varios
-->
o varios
-->
contenedores
-->
bueno aquí salió
-->
un error
-->
y fíjese que me
-->
dice que la
-->
popularidad que es
-->
nula
-->
lo que te
-->
había dicho
-->
entonces
-->
eh
-->
ah no
-->
aquí en realidad
-->
para cualquier
-->
función de
-->
grupo
-->
si hay un
-->
nul sale un
-->
error
-->
entonces
-->
qué pena
-->
aquí popularidad
-->
a sacar
-->
el máximo
-->
como una
-->
función numérica es el
-->
problema
-->
saca el máximo
-->
de ese integer
-->
dale
-->
ignore
-->
nulls por
-->
favor
-->
y vuelve a
-->
ejecutar
-->
nuevamente
-->
solamente
-->
para popularidad
-->
porque
-->
no creo
-->
que haya
-->
error porque
-->
no es
-->
ninguna función
-->
si efectivamente
-->
solamente con
-->
popularidad
-->
efectivamente
-->
y ahí te
-->
están
-->
mostrando
-->
entonces
-->
las
-->
películas
-->
con su
-->
aquí no
-->
se ve
-->
muy bien
-->
pero aquí
-->
tenemos
-->
las
-->
películas
-->
Brenda no sé si
-->
le quita
-->
ignore
-->
null
-->
y vuelve a
-->
ejecutar
-->
o
-->
voy a
-->
verificar
-->
para ver qué
-->
error tiene
-->
dice input string
-->
gear
-->
listo
-->
pareciese
-->
lo siguiente
-->
en que
-->
cuando
-->
intenta
-->
leer
-->
hay un
-->
dato
-->
entero
-->
voy a
-->
ver lo
-->
siguiente
-->
explico
-->
este
-->
error
-->
aquí dice
-->
input string
-->
gear
-->
aquí el
-->
problema
-->
es lo
-->
que
-->
este
-->
entero
-->
lo intenta
-->
convertir
-->
a numérico
-->
pero qué
-->
problema que
-->
tenga un
-->
gear
-->
ya
-->
intenta
-->
convertir
-->
a numérico
-->
sale un
-->
error
-->
cuál es el
-->
problema que
-->
tiene
-->
que está
-->
leyendo
-->
encabezado
-->
como
-->
datos
-->
váyase
-->
al input
-->
por favor
-->
dele doble
-->
al input
-->
hcf
-->
input si está
-->
amable
-->
y note que
-->
en el
-->
header
-->
tiene cero
-->
colóquelo
-->
uno
-->
al decirle
-->
uno
-->
que la
-->
primera
-->
la primera
-->
fila
-->
no la
-->
tome
-->
porque va a
-->
intentar
-->
leer
-->
un entero
-->
y le va a
-->
mandar
-->
gear
-->
intenta
-->
convertirlo
-->
sale un
-->
error
-->
vuelve a
-->
ejecutar
-->
nuevamente
-->
para ver
-->
perfecto
-->
ahí lo tiene
-->
perfecto
-->
ahí
-->
ahora si
-->
quisiésemos
-->
algo en
-->
particular de
-->
esto es
-->
base
-->
del señor
-->
Eclipse
-->
hay veces que
-->
tú quieres
-->
maximizar
-->
por ejemplo
-->
si le damos
-->
doble clic
-->
en una
-->
perspectiva
-->
en esta
-->
de room
-->
le damos doble
-->
clic
-->
dese cuenta
-->
que automáticamente
-->
me maximiza
-->
si
-->
quisiera
-->
colocarlo
-->
nuevamente
-->
en como
-->
estaba
-->
en la
-->
configuración
-->
de tu
-->
de tu
-->
talen
-->
le das
-->
nuevamente doble
-->
clic
-->
y te lo
-->
coloca
-->
en la
-->
posición en que
-->
estaba
-->
la
-->
herramienta
-->
como lo
-->
hayas
-->
definido
-->
hagamos
-->
algo aquí
-->
vamos a
-->
si deseas
-->
vamos a
-->
ordenar
-->
los los
-->
datos
-->
bueno no tiene sentido
-->
vamos a hacer
-->
lo siguiente ahora
-->
vamos a crear
-->
un nuevo
-->
componente
-->
aquí
-->
como ya yo sé que
-->
me
-->
funciona
-->
voy a hacer
-->
lo siguiente
-->
voy a quitar
-->
este
-->
telocrow
-->
bueno
-->
si quieren
-->
lo dejan
-->
también
-->
vamos
-->
aclaro
-->
bueno
-->
la
-->
pregunta
-->
que me
-->
hicieron
-->
ayer
-->
en
-->
cuá
-->
los
-->
datos
-->
tal cosa
-->
lo que
-->
pasa
-->
es que
-->
si
-->
tienen
-->
muchos
-->
datos
-->
mandar
-->
esto
-->
a
-->
consola
-->
te
-->
consume
-->
mucho
-->
tiempo
-->
y el
-->
joke
-->
te va a
-->
demorar
-->
mucho
-->
si
-->
output
-->
significa
-->
a
-->
escribir
-->
en el
-->
sistema de
-->
fichero
-->
del
-->
señor
-->
si esto tiene
-->
un
-->
que tiene
-->
que tener
-->
un esquema
-->
un esquema
-->
con el cual va a
-->
crear
-->
archivo
-->
pero
-->
cuando
-->
conecto
-->
este
-->
telog
-->
con el
-->
telop
-->
automáticamente la salida del Tegar Gate se convierte en entrada en el T, en el T HDFCU.
-->
Bueno, el T-Log no, pero sí podías hacer lo siguiente. Voy a dejarlo como estaba
-->
anteriormente y se lo voy a dejar. Usted hágalo con allá con un, sin el T-Log.
-->
Aquí pude de hecho varias cosas. Si quisieses por ejemplo tener ese T-File en un archivo,
-->
podías aquí cambiar este T-Log por un T-File Output. O si quisieses dejar todavía la
-->
salida, yo pude haber hecho este T HDFCU Output aquí y conecto el T-Log Road con este HDFCU.
-->
¿Qué va a pasar aquí? Que aquí me va a mostrar lo que pasa por aquí y al final lo que pasa
-->
por aquí lo va a mandar acá. Hay varias formas de hacerlo. Al final lo que quiero es que la
-->
salida de aquí me quede en un archivo allá en el clóset dejado. Pero es viable también
-->
este esquema en que dejo este intermedio aquí. Podías dejarlo porque normalmente en
-->
T-Log Road cuando tenemos datos reales, datos de pruebas, y podíamos aquí dejar ese T-Log ahí,
-->
bien funcionaría igual sin o con el T-Log Road. Voy a configurar ahora entonces este Output que está acá.
-->
Lo que les decía como... Sí, dígame. A ver, aquí hay varias cosas.
-->
Bueno, en primer lugar, si el T-Log Road no lo tengo, no tendría un archivo de logs.
-->
En primer lugar. Ahora, hay varios componentes en talent que te pueden mandar. Por ejemplo,
-->
hay un componente que se llama un T-Warning. Este T-Warning que está aquí te manda algunos
-->
warning que tú quieres. Pero el problema donde tú quieres llegar es si el T-Log Road no lo tengo,
-->
¿cómo podría detectar un issue? Aquí... Sí, sí. Ah, sí, listo. Pero ese mensaje tendría que
-->
sacarlo con un componente que es T-Log Catcher. Este T-Log Catcher, sin este T-Log Road,
-->
yo tengo este T-Log Catcher y este T-Log Catcher lo podía mandar a un T-File,
-->
o sea, a un archivo de log físico, de memoria secundaria. Mira lo siguiente,
-->
la idea sería de esta manera. Sin este T-Log Road, podía quitar el T-Log Road y colocar un
-->
T-Log Catcher. Si hay un error aquí en el job, él lo manda al T-Log Catcher,
-->
pero el T-Log Catcher me queda de memoria principal. Entonces, lo que haría es que el
-->
T-Log Catcher lo mandaría a un archivo de log. Perdón, aquí es un T-File Output.
-->
Y tendría mis archivos de log normal de estos jobs. Si me entiendes la idea y si quieres
-->
que esté muerto, te invento un ejemplo más tarde. Pero la idea sería la menor. Sin el T-Log Road,
-->
el T-Log Catcher captura cualquier error que haya aquí y para mantener la memoria
-->
secundaria lo manda a un T-File Output. Si de pronto la idea se dice...
-->
Sí, exactamente, exactamente. Sí señor, así es, efectivamente. Tiene que quedar un T-Log Catcher.
-->
Ah, listo. La única es que el T-Log Road lo manda a consola. Listo. Y el T-Log Catcher,
-->
el T-Log Road mandaría que ella escribiría aquí, pero si hay un error detrás, el T-Log
-->
no lo captura. Entonces, el T-Log Catcher sí captura cualquier error que haya en el flujo y
-->
te guarda el error, en qué posición estaba, y con el T-File lo guardas en un log de memoria
-->
secundaria. Y ahí mantiene tu log listo. Vamos entonces aquí a este THDF Output entonces para
-->
configurarlo. Como les decía, ya yo sabía que usar dos componentes de THDFS, la mejor forma
-->
era con un Conectium. Entonces aquí uso la conexión existente. Nombre del archivo. Si deseas
-->
para que no coloques la ruta, hacemos el fluquito del día de ayer. Voy a buscar un
-->
archivo que esté, voy a coger un archivo que esté en la ubicación que yo quiera, por ejemplo,
-->
aquí, y después le cambio el nombre. En este caso lo voy a llamar Mejores Undercore Películas
-->
por Década. Es para evitar colocar toda la ruta, entonces tomo un archivo que está ahí,
-->
y después le cambio el nombre para que sea mucho más sencillo. Perfecto, entonces aquí le
-->
coloco TextFile, el circuit si todavía no lo he explicado. La acción, si vas a ejecutar varias
-->
veces este yo, mejor coloca Sobreescribir. El añadir lo que hace que cada vez que ejecute le
-->
vaya a ir más datos al archivo como tal, pero en este caso desea solamente Sobreescribir.
-->
El Sobreescribir si no está creado lo crea, y si está creado lo sobreescribe entonces.
-->
Al nombre del archivo, ah, ok, sí. Para ese caso en particular,
-->
déjenme decirle, bueno, pero le adelanto un poco porque si acaso no me da tiempo de
-->
hacerle un ejemplo con eso, pero entonces la herramienta maneja lo que llaman
-->
variables globales. Entonces aquí hay una variable que se llama, por ejemplo, aquí hay
-->
un test global bar, este señor me permite crear variables globales, entonces imagínate un programa
-->
que tú define la variable que sea aquí, la voy a colocar aquí, nombreArchivo, nombreArchivo.
-->
Listo, entonces aquí defino la variable. Podría usar un componente que se llama
-->
Tjava que monte primero, y aquí por si algo le digo a la variable que llamé nombreArchivo,
-->
le puedo colocar aquí un nombre que se genere a través de, tome la fecha del día y define
-->
el nombre. Y lo que hago acá es que en vez de mandarle a colocar aquí el nombre,
-->
hago una concatenación con la variable global. Sé que lo dije muy rápidamente,
-->
pero voy a intentar entonces hacer un ejemplo con este para ver si salen, pero sería la forma en
-->
que haría dinámico el nombre. Defino una variable, la variable le cambia el valor cada vez que
-->
ejecute y listo, perfectamente puedo concatenar con el nuevo valor y me da. Listo, es que es
-->
muy este, normalmente aquí ya llevábamos toda la teoría, cuando estaba este curso antes
-->
teníamos toda la teoría ya está básica del talent y ya tú sabías cómo resolver estos
-->
problemas que me estabas preguntando. Pero bueno, vamos a ver, vamos a intentar ejecutar aquí este
-->
señor de acá, listo run acá, debería ahora hacer lo siguiente, debería generar, como tengo
-->
el telorode por la mitad, me va a mostrar los datos que pasan por ahí y al final me
-->
debería mandar el archivo al clóser de Hadoop. Dice que aquí no hubo problema, entonces voy
-->
a revisar acá el clóser de Hadoop, tengo esta, un momento a ver qué, ahora sí, bueno aquí
-->
tengo el clóser de Hadoop y aquí está, bueno no estaba, F5, ya tengo mejores películas por
-->
década, voy a bajar aquí y voy a descarguelo aquí mismo por favor desde la interfaz y
-->
veamos cómo nos quedó el archivo, el archivo me quedó sin encabezados, se me
-->
dejó colocar los encabezados. Sí, se nos olvidó configurar ese encabezado, entonces
-->
voy aquí, que raro porque me está dando eso acá, voy aquí a este señor acá y le
-->
digo incluir header en la parte de abajo, incluir header, se va al output, por favor a
-->
confusión del output y en la última opción hay un chulito que dice incluir header acá,
-->
incluir header acá en la parte de abajo ya, bajito y lo vuelvo a ejecutar nuevamente y
-->
debería agregar los encabezados. Vamos a ver entonces, debería de este lado.
-->
¿Quién me habló? Sí, normalmente cuando se cambia o quiero volver al mismo lugar le da
-->
nuevamente doble clic, pero ahora tiene algo, lo que hace es que le cambió, lo que estaba acá
-->
abajo en la confusión que tiene acá abajo, la tiene ahora del lado izquierdo porque le
-->
cambió la forma de perspectiva. Haga lo siguiente ahora, ok, dígale lo que hay ahí,
-->
note en la parte, no sé si me voy a mostrar su pantalla aquí, mire que de este lado es que
-->
tiene ahora la configuración que tenía acá, entonces si da clic aquí, por ejemplo, dele
-->
clic aquí a donde está como la paleta esa, dele clic ahí, espere que ahora, dele doble
-->
clic a eso y debería colocársela abajo, dele aquí donde dice component, doble clic,
-->
nuevamente doble clic y ahí va armando nuevamente. Ahora, ese run, dele doble clic nuevamente
-->
y ahora doble clic nuevamente ahí en la parte de arriba, espere un momento,
-->
hay que cerrar ese, se nos cambió la forma. Listo, perfecto, sí, así es. Intente ejecutar
-->
ahora nuevamente, ya creo que ya ejecutó, no sé si ya había ejecutado, creo que le cambió
-->
alguna configuración. Váyase al basic, ahí en la parte de abajo está en memory run,
-->
váyase en basic run porque ahí está haciendo es, váyase aquí, memory run, suba a la
-->
primera opción que es basic run para si vuelve a ejecutar ahí porque ahí está haciendo era
-->
un análisis de memory ahí. No sé, Fernanda, en el caso suyo salió un error allá, suba para ver,
-->
suba para ver ahí en donde está el run, suba a la barra de, a ver qué error puede salir ahí,
-->
suba y suba, está al principio, normalmente sale en el principio. Ahí está, la segunda
-->
línea dice que ya existe. Sí, exactamente, porque ya existe, dele doble clic al output,
-->
por favor, listo, perdón, dele ejecutar ahora, listo, perfecto, entonces continuamos,
-->
a ver si me da tiempo de hacer un ejemplito con alguna IA y podamos relacionar el job con IA.
-->
Bueno, vamos a crear otro ejercicio aquí entonces, ya cerramos este de aquí,
-->
vamos y vamos a crear aquí create job, un nuevo job, vamos a hacer lo siguiente,
-->
job, lo vamos a llamar job, calcular, producción,
-->
por estado, temporada, es decir, vamos a hacer entonces a sacar los datos de
-->
cuánto es la producción por estado y por temporada. Vamos a ver aquí finish,
-->
vamos, que venga, vamos a abrir el anterior para tomar la configuración de conexión,
-->
este vamos a tener, listo, esto que es aquí, vamos a copiar
-->
y vamos a pegarlo acá, para no tener que volver a configurar eso.
-->
Listo, voy a cerrar esto que ya no me interesa este lado.
-->
Vamos entonces a hacer lo siguiente ahora, vamos a tener un HDFS input,
-->
HDFS input, vamos a tener ahora un THDFS output,
-->
vamos a tener un T-aggregator row nuevamente,
-->
agregue otro THDFS input si es tan amable,
-->
input
-->
y esto es para ejemplificar aquí, coloque un THDFS row.
-->
Bueno, listo, entonces este es el archivo que vamos a manejar, nos piden, esto lo que hace es que
-->
tiene el valor de la por estado, por distrito, por año, por temporada, cuánto se ha cultivado
-->
y cuándo fue la producción, cuánto, digamos, cuánto tomé de la cosecha que tuvo,
-->
y vamos a hacer lo siguiente ahora. En primer lugar, voy a tomar del HD,
-->
que lo hicimos el día de ayer, tomamos y creamos, subimos el archivo que se llama
-->
producción, entonces vamos a hacer lo siguiente, este HDFS input que está aquí,
-->
voy a decirle usar conexión existente,
-->
defino la conexión aquí, y ahora voy a tomar como referencia el archivo que se llama producción.csv,
-->
perfecto, producción, ahora necesito el esquema de producción,
-->
necesito el esquema, que es la recomendación que te hago yo cuando tienes varios archivos,
-->
tiene muchas columnas, carece de sentido que lo haga de forma manual, entonces créate,
-->
en una porción de ese archivo muy pequeño y vamos a crear una metadata de ese archivo,
-->
vamos entonces aquí a decirle file delimited, clic derecho y crear file delimited,
-->
esto lo estoy haciendo simplemente para tomar las columnas y el orden y los tipos de
-->
datos en que están, lo voy a llamar producción, en español producción, next aquí,
-->
busca tu carpeta temporal y ahí vas a encontrar el archivito de producción,
-->
en un ambiente real pues no vas a tener archivo completo, vas a tener solamente las columnas,
-->
nada más abrir, next, está separado por coma y el día de ayer te comenté acerca de la
-->
codificación, normalmente pues con un UTF-8 te debe bastar pero en algunos casos, en español
-->
el Windows 15-52 te puede servir mucho mejor, le digo que tiene encabezado y que está separado
-->
por coma y después le doy refresh para ver que todo esté bien, listo y aquí lo que quiero
-->
sacar es cuánto he hecho por producción, por estado y por temporada, sé cuánto he producido,
-->
por estado y por temporada, es lo que quiero, dale aquí next y el día de ayer lo hicimos
-->
un poco diferente, vamos a exportar automáticamente este señor, en la penúltimo botón, vamos a
-->
exportarlo directamente el esquema, en el penúltimo botón de esta ventana, le das click ahí y va
-->
a exportar el esquema, si dígame, el que perdón, el name de la producción, producción,
-->
será producción list y aquí vamos a llamarlo entonces producción.xml, esto fue lo que hicimos
-->
el día de ayer, la diferencia es que el día de ayer lo hicimos ya cuando estaba creado,
-->
este es cuando lo está terminando de crear, entonces me lleva listo a guardar y le doy
-->
finish aquí, si digo, Beatriz voy a ir para ver, primero ya creo el archivo delimitado,
-->
no, vamos a ver, dele click derecho ahí en donde está en la metadata, justamente en
-->
click derecho, a un momento, a qué pena, que me equivoco, que fue de pantalla, listo,
-->
ahí está en el penúltimo botón, dele next por favor, dele next, y ahora en el penúltimo
-->
botón de esta ventana, listo, vamos a hacer lo mismo que hicimos el día de ayer, coloque
-->
ahí entonces producción y asegúrse de terminar con xml, dele guardar ahí, finish por favor y
-->
listo, vamos por ahí, ahora vamos a tomar ese esquema que está ahí, vamos nuevamente a hfs
-->
input, que asegúrese donde dice editar esquema, que en este caso está en la parte de arriba y
-->
en el penúltimo botón es para importar, busque entonces aquí producción, vamos a darle
-->
aquí ok y ya tuvo que haber importado entonces el esquema exactamente con los nombres de
-->
que para el caso de talent pues es irrelevante, lo más importante es el orden y el tipo de datos
-->
de cómo vas a sacar las columnas, si quiere le puede cambiar el nombre, pero bueno, normalmente
-->
uno a nivel de producción deja los mismos nombres, acto seguido vamos entonces a conectar
-->
aquí con el t-aggregated y el t-aggregated row lo conectamos con el hdfs output,
-->
listo entonces repasemos este componente que es muy usado a nivel de cuando voy a sacar algunos
-->
cálculos porque recordará que cuando yo voy a analizar algo analizo en conjunto para ver la
-->
frecuencia que puede tener los datos, entonces vamos al t-aggregated row y vamos entonces
-->
donde dice editar esquema, en el caso anterior utilicé los mismos nombres de columna que me
-->
tenían de aquí de entrada, voy a hacerlo un poco diferente, si los nombres de entrada tú
-->
lo quieres conservar pues lo más lógico es que tomes de aquí para evitar para hacer más rápido
-->
y lo mandes para este lado como fue el caso de ayer, el caso del proceso pasado, voy a crear
-->
ahora unas nuevas variables que son las que voy a sacar, entonces las voy a colocar en
-->
español ahora, aquí tengo un más y este más lo voy a llamar entonces aquí me agregó una
-->
nueva fila, voy a darle clic ahí donde dice new column y la voy a llamar estado en español,
-->
tipo de dato stream, por qué lo hice diferente la vez pasada es porque muchas veces vas a
-->
quisiera conservar los mismos nombres entonces era más rápido que pasar los nombres que tenía
-->
y los tipos de datos, aquí lo voy a hacer un poco diferente por si acaso te toca hacerlo
-->
de esta manera alguna vez, estado voy a colocar aquí, voy a agregar una nueva columna
-->
que la voy a llamar temporada, que también es temporada y voy a agregar entonces
-->
una nueva columna, la voy a llamar estilo snake case total underscore producción
-->
y aquí es donde va a quedar la sumatoria de esa producción, entonces como voy a sumar
-->
datos que son numéricos, el tipo de datos no podía ser string entonces, entonces voy a
-->
expandir aquí y voy a escoger el tipo de datos más conveniente, para este caso entonces
-->
aquí tiene, java tiene estos tipos de datos son directamente de java, entonces aquí tiene
-->
lo siguiente, si sus datos son de tipo enteros entonces java tiene integer y tiene long,
-->
integer le ocupa menos cantidad que long, el long si es un dato mucho más grande y de igual
-->
forma tengo, para reales tengo flowat que es para reales y tengo doble, si el doble, si el número
-->
es muy grande entonces usa el doble, si no, usa flowat, si no cabe en un doble, java tiene un
-->
tipo de datos especiales que se llama big decimal que ahí aparece, que lo que hace internamente
-->
es que maneja el dato como si fuese un string, o sea hace unos cálculos matemáticos pero lo
-->
guarda al final como si fuese un string, pero no es el caso la cantidad de datos no me da
-->
para big decimal entonces use por favor doble. Este icono que está aquí, perdón este chulito que
-->
está ahí en el medio que se llama clave, perdón, esto es, esta clave se usa cuando
-->
ejemplifico, son muchas cosas que de pronto estoy metiendo la cabeza, esa clave que está ahí se usa
-->
es, supongamos que tú quisieses mandar esos datos en una tabla a la base de datos, entonces
-->
yo coloco una clave, me manda ese dato como si fuera ya de primaria, me colocó un primaria
-->
aquí a ese campo, pero no es el caso, te estoy informando y acá recuerde que este nullable es
-->
el mismo chulito que hicimos con el caso de la variable en el tema que si iba a recibir nulo
-->
la chuleabas, si sabes que no va a recibir nulo entonces pues no la chuleas, no quiero
-->
la chuleabas y ahora voy a agrupar entonces como quiero que es sacar por estado y por temporada
-->
me toca hacer en el group by, me tengo que agrupar entonces primero por estado y después por
-->
temporada, recuerda que el orden en que agrupes te va a dar diferente entonces primero voy a
-->
agrupar por estado, voy a darle aquí clic y aquí me dice estado y acá tienes que mapearlo
-->
con la columna de entrada que sería state name, perfecto ahí mapeo bien, agrega ahora una nueva
-->
columna temporada y mapearlo con la columna temporada de entrada que sería season, listo
-->
no vamos a seguir agrupando, vamos a definir entonces una función de grupo, vamos a darle
-->
entonces aquí en el más y aquí me va a aparecer las las columnas que todavía están
-->
libres ya yo había usado temporada y estado y nada más tenía producción entonces función aquí
-->
la función sería suma y que columna vas a sumar entonces spande y hay una columna que
-->
se llama producción y el error que vimos pues normalmente cuando es matemático si
-->
hay algún nulo entonces voy aquí ignore null para que me funcione pero recuerda que como
-->
recomendación si tú sabes que no debe haber nulo no debes colocar ese ignore de tal forma
-->
que salga un error si de pronto viene un nulo. Configuramos el HDFS output digo usar conexión
-->
existente y ahora voy a hacer lo siguiente entonces voy a escribir nombre archivo mismo
-->
truco que apliqué ahora voy a buscar un nombre archivo que esté en la carpeta donde yo quiero
-->
perdón aquí no especificé la conexión aquí en el combo voz amplió aquí y escojo aquí
-->
bueno cualquier archivo que al final lo voy a cambiar el nombre y lo voy a llamar entonces
-->
producción on the record por on the record temporada perdón por estado on the record
-->
temporada. Aquí un par de recomendaciones
-->
el problema de las codificaciones ya habíamos visto en el Tefalinput que hay varias
-->
codificaciones ASCII, ISO, la ISO, la ANSI entonces te voy a recomendar en que los JOTS ya adopte
-->
su sistema de codificación el que tú ya has definido por estándar normalmente casa como UTF-8
-->
por ejemplo aquí sitúa codificación personalizada por defecto está en ISO,
-->
ese ISO es inglés si los datos tienen español y le mandas para ISO allá cuando los vayas
-->
a leer baja tiene un pequeño problema entonces normalmente acostumbra pues a usar
-->
estándar que tú ya definido UTF-8 no sé el que hayas definido pero si los datos en español
-->
mejor que se casen con un estándar de UTF-8 si de pronto es europeo el ISO le funciona
-->
perfectamente eso lo quería mencionar aquí y lo último aquí es esa parte de compresión
-->
de datos pasa lo siguiente en que recordará que por la forma de clostrización que se tiene
-->
que está en este caso de JADUT JADUT lo que tiene es lo siguiente toma un archivo y lo
-->
divide en diferentes partes o particiones pero esas particiones la réplica por una cuestión
-->
netamente de redundancia por si acaso se daña alguna particiones por ejemplo si notamos aquí
-->
esta partición de JADUT acá nota que aquí tengo una replicación de 3 significa que este
-->
señor va a replicar tres veces la misma partición eso te va a ampliar a digamos en
-->
en gran medida el almacenamiento que vas a ocupar en memoria secundaria la ventaja que tienes con
-->
esto es que la memoria secundaria es muy barata a nivel de clau pero quizás hay archivos que
-->
son muy grandes entonces la herramienta te permite hacer lo siguiente te permite comprimir
-->
los datos entonces de aquí una compresión de datos y aquí están varios formatos de
-->
compresión estos formatos de compresión vienen directamente del mundo de UNIX aquí está
-->
si y vamos a quedar aquí incluir hider incluir listo ahora vamos a hacer lo siguiente quiero
-->
ahora leer este archivo porque lo quiero leer es porque cuando está comprimido tienes que leerlo
-->
tienes que especificar que está comprimido aquí me adelanté un poco a usar este como yo
-->
perdón no me adelanté que pena no me olvide lo último que di no me adelanté entonces
-->
qué vamos a hacer ahora este hdf input va a leer este archivo que voy a escribir acá
-->
entonces que voy a hacer estando en el hdfs up voy a copiar la ruta del archivo el
-->
nombre del archivo la voy a copiar y la voy a pegar en hdfs input aquí voy a configurar
-->
que voy a usar una conexión existente configuro la conexión y voy a pegar aquí el nombre del
-->
archivo de salida que tengo en el hdfs listo ahora que voy a hacer recuerde que todo lo
-->
input y output que tenga tiene que tener un esquema el esquema de entrada tiene que ser
-->
el mismo esquema de salida de este archivo que está aquí por ende ya yo sé que este
-->
hasta acá voy a este a este output le digo editar esquema y voy a exportar el esquema
-->
este que estado que está aquí donde está este sería la antepenúltima opción aquí la
-->
antepenúltimo botón perdón antepenúltimo botón y lo voy a llamar entonces producción
-->
temporada producción
-->
temporada punto xml te doy aquí guardar
-->
cierro aquí con ok y lo que hago ahora me voy al input al esquema del input y aquí si es
-->
el penúltimo botón y busco entonces el archivo del esquema que exporte abrir y
-->
debería dar entonces listo aquí damos ok
-->
y por último conecto el input
-->
con este teloro ah listo sí perfecto y lleva hider pero el momento en el input listo
-->
estoy no con si si gracias entonces en el input tengo que hacer aquí tendría que tener
-->
un hider la codificación tendría que ser la misma que sería utf-8 y necesariamente tendría
-->
que descomprimir los datos porque vienen comprimido la descomprensión tendría que
-->
estar en el mismo algoritmo que colocarte el op vamos ya lo exportó o todavía falta
-->
importarlo había por dónde va bueno bien vamos primero a exportarlo primero nos vamos
-->
al hdfs output le da en editar el esquema este esquema de salida para exportarlo va a ser
-->
el tercer bot el atp no último botón que dice export all y aquí lo exporta llamélo
-->
producción temporada y aseguré que sea punto xml si están a mal dele ok perfectamente ahora
-->
se va al input al hfs input y edita el esquema del hdf input perfecto editar esquema y ahora
-->
importa que sería el botoncito el penúltimo botoncito penúltimo botón y busca el archivo
-->
que ya había exportado listo header en uno la codificación tiene que ser igual a la del output
-->
si la codificación del hfs output está en utf-8 como el caso mío que la cambie aquí en utf-8
-->
la el input también tendría que estar en utf-8 si no la configuró no hay ningún problema porque
-->
la bala por defecto que sería la hizo y por último como este archivo lo comprimió tiene
-->
que descomprimirlo en el mismo algoritmo de ese cuenta que en el output yo comprimí con
-->
jett con jesset y acá voy a descomprimir con jesset bien cuánto su job habría en ese trabajo
-->
que está ahí a ver si no acordamos ahí cuánto su yo que habrían ahí habrían tres verdad el
-->
tepe yo el segundo su job y el tercer su yo aquí por defecto aquí me funcionaría bien en el caso
-->
particular por qué porque no tiene que darse ese y después este pero como buena práctica y quizá
-->
porque se te puede olvidar a ti mejor define el orden jerárquico si hay una jerarquía define
-->
la jerarquía de los su job entonces recordamos cómo hacíamos esto vamos al primer su job a
-->
elemento del su job 1 y voy a conectarlo con el disparador con su job ok hacia el primer
-->
componente del su job aunque la ejecución da igual este este yo que se puede leer más
-->
fácilmente porque sé que se ejecuta primero y después que se ejecuta después listo entonces
-->
voy a hacer aquí voy a ejecutar aquí verifiquen el ron que sea igual al que está ejecutando
-->
y vamos a ejecutar este señor
-->
aquí me sale un error dice no puede ser progresado porque incompatible o
-->
no sé no es raro extrañamente raro
-->
bueno ahí está los datos en que salió un warning ahí pero no sé por qué se lo
-->
hace warning ahí está entonces por ejemplo voy a sacar solamente dos dáticos aquí nada más
-->
para verlos aquí lo que veo raro es que no me lo está formateando bien parece ser que no
-->
lo está formateando bien el separador de campo acá es punto y coma y el separador
-->
es punto y coma no sé parece que no está como que
-->
hay algunos que tienen errores voy a verificar entonces aquí luis está preguntando algo para ver
-->
en el esquema el campo producción viene definido como stream a ok bien stream porque
-->
bien stream entiendo
-->
ah claro aquí está como es trin lo tomó mal y por eso que sale error
-->
bueno si quieres vamos aquí voy a cambiar el problema que tiene déjame un momentico ahí
-->
y solución aquí los demás porque yo te entendí la idea muchas gracias no me da cuenta
-->
voy a voy voy en el caso de luis que tiene a listo luis a ti salió error entonces vamos a
-->
ver el error te salió en el no porque ese input que está ejecutando luis
-->
el de abajo es el vete a tu hdf o por un momento luis hdf o por un momento
-->
ya está sube eso coloca lo más porque si no perfecto ese que está ahí
-->
es que está ejecutando al revés luis yo está buscando la chido que yo está creado
-->
borra el subyop borra el pt perdón borra la flecha del onsujok ok
-->
que están a mal de onsujok ok borrala ahora vete y dale clic derecho al input el de abajo
-->
y ahora sí dale clic derecho disparador porque se se ejecuta primero onsujok ok con el de
-->
arriba y porque estaba buscando el archivo que tuvimos está creado ejecuta ahora sí para ver
-->
y ahí está total producción porque ahora le cambiamos el tipo de datos para solucionar
-->
el problema perfecto liso el problema que tenías era el que tenías al revés el quién más perfecto
-->
vamos a solucionar el problema este del del warning que me sale este warning ojo lo
-->
siguiente y sería interesante bueno interesante que haya pasado esto el problema que tengo es
-->
que en el te agregué este robo todo haciendo una suma de un dato que es entero entonces
-->
mira lo siguiente yo pude haber cambiado el tipo de datos aquí en el te agregué este row de
-->
a doble el problema que tengo es que el señor viene string y va a intentar convertir el string
-->
a doble y va a tener un error entonces aquí lo mejor es convertirlo desde el inicio vete acá
-->
al hfs este este output editar esquema y conviértelo a doble que creo que sé por qué lo hizo
-->
conviértelo un momento a doble este señor se me perdió el doble aquí está doble
-->
entre pasa lo siguiente que muchas veces yo con cambio aquí al inicio y los elementos que
-->
siguen a continuación no los cambia entonces hay que verificar que el doble siga en el
-->
siguiente componente voy aquí al te agregué terro voy aquí a editar esquema y si si lo
-->
cambió si lo cambió lo cambié al inicio y cambió la cadena hay veces que no lo hace ahora
-->
vamos a ejecutarlo para ver si no sale error porque quizás salga un pequeñito error
-->
listo aquí el error fue porque no coloqué para que sólo escribiera entonces voy a dar
-->
aquí over white brenda tiene un error ahí ya voy a ver para ver qué tiene cuál error que tiene
-->
ya un momento para ver bueno perfecto ahí salió listo perfecto ningún problema ok ese
-->
era el warning que teníamos muchas gracias luis aquí no es necesario que lo cambies en
-->
el input 2 el porque el input 2 te quedó como te quedó como string a no no perdón no qué pena
-->
confusión bien quién era brenda que tiene error muestrame el room dale click en el room brenda
-->
por favor si está mal para ver qué error tiene dice todo no puede ser progresada diva
-->
entonces después nombre a total producción a listo bs al hfc input por favor al 2 al 2
-->
exactamente 6 de doble clic si está mal ahí fue porque no lo colocó encabezado entonces
-->
intenta leer intenta convertir un string a entero y no la elegir tiene que estar en uno corrida
-->
inmediatamente váyase al che al hfc output al 1 por favor si están amables al esquema del 1
-->
al hfs el 1 gracias al perdón al input que pena al input hfs input 1 no así si tiene
-->
colocarle 1 también 1 porque tiene encabezado váyase a editar esquema un momento de ese
-->
ahí editar esquema ahí cambie production el tipo de datos que está en string cambia
-->
los dobles si están amables el último ahí entre dele ahí lo tomó dele que yes ejecute
-->
ahora para ver nuevamente ya se alte al hf output y cambie de crear a overwrite doble
-->
clic ahí y cambie action el action de crear a sobre escribir y vuelve a ejecutar nuevamente
-->
perfecto ahora sí listo ok listo si va a la a su cluster de hadut f5
-->
que sería este punto csv ya la como en es más la extensión carece de sentido porque ya
-->
pierdo el formato de más si yo lo descargo aquí creo que me debe salir como un formato
-->
binario algo así por el estilo ahí está porque está está comprimido
-->
cuánto pesa el archivo a ver 3 3 puntos megas permítame y hago aquí una
-->
una pequeña observación voy a ejecutarlo sin no la guste simplemente para verlo acá
-->
no lo voy a comprimir
-->
y voy a ver cuánto pesaría para comprar los dos voy a cambiar aquí el nombre para ver más
-->
o menos cuánto aunque el archivo muy pequeño entonces quizás no se ve tan claro porque
-->
muy pequeño archivo listo ahí está ejecutando perfecto f5 vea el original pesa sin comprimir
-->
14 megas y comprimido da 3 megas y comprimir bastante comprimir bastante bueno continuamos
-->
con otro ejemplo y vamos a hacer un join ahora como hacemos un join acá entonces perfecto listo
-->
voy a sacar lo siguiente mire tengo los datos esto de esta manera voy a tomar aquí estado
-->
bueno listo voy a sacar nada más estos tres campos aquí que sería crochet listo y producción
-->
quiero sacar la mayor producción por año entonces primero me tocaría sumar todas
-->
las producciones que haya en ese año y después saco la mayor que tenga desde cuenta que el
-->
mayor que como lo hice anteriormente creo que lo tenía por aquí no sé este que está aquí
-->
este esta forma que hice yo era para introducir el texor no me funcionaría en todos los casos
-->
porque puede hacer el caso en que haya dos películas para este caso muy particular que
-->
tenga la mayor popularidad por ejemplo yo puedo tener aquí x con propiedades 92 aquí en realidad
-->
que el dato me tenía que dar 2 pero como yo estoy sacando solamente el primero nada más me
-->
mostraría este que está aquí entonces realidad esa consulta o ese yo de la forma
-->
en que lo tengo puede que me cause algunos problemas porque quizás haya varios películas
-->
que tengan la mayor popularidad por ende voy a hacer entonces el ejercicio de forma diferente
-->
esto entonces voy a hacer lo siguiente voy a sacar ahora la mayor producción que hay por año
-->
listo esto este solo voy a hacer es para incluir cómo se haría un join entre varios
-->
archivos para esto entonces vamos a irnos nuevamente al talent
-->
y vamos entonces a crear aquí en el big data que está acá
-->
clic derecho y voy a crear un nuevo yo
-->
este yo que lo voy a crear entonces yo lo voy a llamar calcular mayor
-->
under score producción por año coloque por anualidad porque no le va a aceptar el
-->
año entonces colócale por anualidad yo calcular mayor producción por anualidad
-->
como le decía voy a tratar de hacer los archivos de forma diferente cada
-->
yo para poder incluir componentes nuevos le damos aquí entonces finish
-->
y cópiese del anterior las conexiones por favor
-->
creo los siguientes elementos agregué un hdfs es más como es el mismo archivo por favor
-->
en el pasado cópiese el input de producción y fue el primer thdfs input entonces voy a la
-->
anterior al estado temporada que me sirve cuando tengo que volver a configurar eso
-->
voy a tomar el hdfs el input 1 que es el que le de producción y lo voy a pegar acá se
-->
me escapaba y con esto entonces para evitar tener que volver a configurar algo que ya
-->
ve lo que voy a hacer primero voy a obtener cuál es la mayor producción por año ok cuál
-->
es la mayor producción por año y después saco entonces los demás elementos entonces
-->
voy a hacer lo siguiente voy a agregar aquí ahora un aggregator row y ya está lo más
-->
lo manejamos voy a agregar aquí un thdfs output
-->
y voy entonces a hacer las conexiones aquí
-->
vamos a conectarlo aquí a este output
-->
listo entonces voy a sacar lo mismo ahora mira lo que voy a hacer primero
-->
voy a calcular cuánto ha sido la producción que he tenido por estado por temporada y por año
-->
me toca hacer la sumatoria pero voy a hacer algo particular diferente a la que tenía
-->
anteriormente voy a mandar esto primero a un archivo entonces voy a hacer aquí lo siguiente
-->
voy aquí al aggregator row voy entonces aquí donde dice editar esquema voy a sacar entonces
-->
aquí la columna estado voy a la columna temporada el anterior fue que saqué la producción por
-->
temporada y por estado esta va a sacar por estado temporada y por año se voy a colocar
-->
aquí un nuevo que se llame anualidad y este que está aquí va a ser de tipo integer y
-->
voy a colocar aquí total total on record producción y este va a ser de tipo doble
-->
la diferencia que hay el anteriormente solamente tenía la producción por estado y temporada
-->
aquí va a sacar la producción por estado temporada y por año ok y es
-->
configuramos entonces el group by que sería agrupar aquí espero un momento que algunos
-->
que todavía han terminado listo el te agregué este row entonces vamos a agrupar por primero
-->
por estado en este caso mapea la columna de salida está bien mapeada con la columna
-->
entrada vamos a agregar la temporada que si me toca cambiar así son
-->
voy a agrupar ahora por anualidad que sería crop gear
-->
y vamos a hacer entonces una operación en el total voy a hacer una suma
-->
de la producción que tengo y voy a ignorar null por el problema que tuve ahora parecido
-->
al otro la única diferencia que hay es que ahora voy a agrupar por estado temporada y
-->
por año el anterior solamente agrupe por estado y temporada ahora quiero saber cuál
-->
es la producción tanto por estado temporada y por año ahora en el hdfs output haga lo
-->
siguiente entonces configuremos usar conexión existente busque un archivo que ya esté aquí
-->
se me olvidó configurarla aquí
-->
un archivo que esté aquí cualquiera y lo va a llamar este archivo de salida producción
-->
llámelo producción
-->
producción estado under score temporada anualidad listo aquí le da sobre escribir
-->
por si acaso lo vamos a ejecutar varias veces y dígale que incluya el hdfs voy a hacer un
-->
ejemplo entonces mientras usted va haciendo esa parte de aquí tenemos estado en ese momento
-->
para mostrarle cómo quedaría los datos
-->
si más o menos ese archivo de salida va a quedar de esta manera tengo el estado y tengo
-->
cada temporada el año y voy a sacar la producción por año más o menos me quedaría así se me
-->
repite varias veces el estado temporada y por cada año en la temporada me va a calcular el
-->
valor eso es lo que va a volver hasta aquí estamos hasta aquí ahora quiero sacar lo
-->
quiero sacar el máximo de cada grupo que está aquí entonces si analiza el máximo
-->
el máximo de aquí cuál sería carrito sería de aquí sería este de aquí verdad sería el máximo
-->
si saco el máximo de acá sería este registro de acá o sea el que el año que más tiene o sea
-->
tengo hasta aquí voy a sacar estos máximos de acá se voy a crear aquí voy a colocarle para
-->
identificar voy a colocarle aquí una nota aquí voy a colocar se obtienen se obtiene lo producido
-->
por año producido por año en cada estado y temporada eso lo que se hace aquí lo acomoda
-->
como usted quiera para poder bajar esto tiene que hacerlo acá directamente en el
-->
aquí creo también lo puedo hacer aquí lo puedo hacer aquí lo voy a bajar para que me quede así
-->
bueno no me está bajado ahí está esto hace esto voy a hacer lo siguiente entonces
-->
voy a sacar la segunda parte que es esta que está aquí entonces para esto vamos a hacer
-->
lo siguiente voy a hacer lo siguiente voy a hacer aquí un hdfs input nuevamente un
-->
te agregué terro te agregué terro te agregué terro y voy a mandar a este señor a un thdfs output
-->
porque así vamos a ver si así
-->
la única forma de hacer esto es lo siguiente este año no lo puedo sacar así directamente
-->
sino a partir de cómo está el archivo yo voy a sacar el máximo valor o sea en pocas palabras
-->
cuál es el máximo producido en esta en esto sería esta fila de aquí entonces que voy a
-->
hacer yo voy a agrupar por estado y temporada y voy a sacar el max producido eso lo que
-->
voy a hacer en este agregate significa que me está dando al final estaría dando en el
-->
grupo este de aquí me estaría dando x a y me estaría dando 13 en este grupo de acá que
-->
voy a hacer voy a agrupar por estado y temporada y sacar el máximo me estaría dando x
-->
b y aquí me estaría dando 18 y después hago un join de estos dos archivos para
-->
poder sacar el año aclaro que lo estoy haciendo así es para poder incursionar
-->
en el join vamos a lo siguiente vamos aquí vamos a conectar este señor de aquí con este de acá
-->
y voy a conectar este te agregué este rub con este de acá
-->
el archivo que voy a leer aquí es el archivo producido en este punto de acá
-->
entonces voy a hacer lo siguiente voy a exportar el esquema de aquí editar esquema
-->
ya saben cómo es aquí voy aquí al output editar esquema y aquí sería la antepenúltima
-->
exporto y lo voy a llamar entonces producción estado temporada año anualidad porque no es
-->
anualidad punto xml ok del output me robo el nombre del archivo para poderlo copiar allá en el input
-->
aquí usar conexión existente sí dígame
-->
Beatriz vamos a ver si está raro un momento permítame y accedo de forma
-->
interactiva para poder manipular su pantalla voy a darle aquí un guardar aquí un momento voy a
-->
hacer no sé si pronto fue voy a cerrar este señor de acá volverlo a ir para ver no sé fue
-->
algo extraño hay que ese algo extraño ahí no sigamos entonces no sé qué pasó ahí algo
-->
extrañamente raro ya se quitó ahí se realicen el ingeniero bueno aquí el input este que está
-->
aquí editamos el esquema y exporto aquí y aquí sería producción estado temporada anualidad ok
-->
ese en realidad estoy sacando el máximo de un grupo que normalmente uno lo hace con un sub
-->
query acá lo que voy a hacer es que voy a dividirlo en dos archivos y después hago un
-->
de los dos y resuelvo el problema voy a esperar que algunos están
-->
mientras algunos que todavía están mientras espero alguno me regala
-->
dos minutos con café y vengo a seguir inmediatamente con café mientras algunos terminan ahí ya