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
-->
¿No? Sí, sí, sí, sí, sí, sí.
-->
Alejandro, nota entonces en el
-->
escritorio, en la parte derecha
-->
vertical, hay un ícono
-->
accesorio que dice TOSBD, el
-->
segundo. Dale doble clic, por
-->
favor. Sale un pequeño
-->
warning. ¿Por qué sale ese
-->
warning ahí? Porque como les
-->
decía en la parte introductoria
-->
del ecosistema de talent, la
-->
versión es open source,
-->
solamente dieron soporte hasta
-->
el año pasado. Entonces, él
-->
está intentando conectarse a un
-->
repositorio que ya no está
-->
activo. Dale OK, por favor,
-->
eso no va a afectar lo que
-->
vamos a hacer. En
-->
características de las
-->
herramientas de talent, sea
-->
talent big data, talent data
-->
integration, talent SB, es
-->
que la interfaz es
-->
compartida, es la misma. Lo
-->
que te va a diferenciar,
-->
siento algunos elementos de
-->
forma, quizá colores o
-->
configuraciones muy
-->
específicas. Y lo otro que
-->
te puede cambiar son los
-->
componentes que puedes
-->
encontrar en la versión
-->
open source y en la versión
-->
propietaria. Eso es lo
-->
único que te va a cambiar,
-->
pero la interfaz sigue
-->
siendo prácticamente la
-->
misma. Voy rápidamente a
-->
explicar cada uno de los
-->
elementos de la interfaz.
-->
Nota que a nivel, esto se
-->
llaman perspectivas. Si tú
-->
quieres, llámalo pestañas.
-->
Aquí tengo una perspectiva
-->
que se llama repositorio.
-->
Esta perspectiva repositorio
-->
está compuesta por un menú.
-->
Primero tienes el job
-->
design. En esa parte es que
-->
vas a definir los
-->
diferentes jobs. Recuerda
-->
que en una herramienta de
-->
STL algunos lo llaman job,
-->
otros lo llaman workflow,
-->
otros lo llaman pipeline.
-->
Básicamente va a definir
-->
los jobs donde va a tener
-->
un conjunto de componentes
-->
para ser procesados y
-->
transformar los datos en
-->
el formato que tú quieras.
-->
Segundo elemento que tú vas
-->
a ver aquí, vas a ver
-->
que hay algo que se llama
-->
contextos. Ese contexto se
-->
asocia a variables de
-->
entorno. Esas variables de
-->
entorno recordará que esas
-->
variables tú las clasificas
-->
en variables de tipo.
-->
Normalmente en un sistema de
-->
desarrollo software las
-->
clasificas en entorno QA,
-->
entorno de producción y hay
-->
algunos que agregan un nuevo
-->
entorno que es un entorno
-->
de nivel o pro desarrollo.
-->
Entonces esas variables de
-->
entorno las puedes hacer y
-->
cómo las maneja la
-->
herramienta a través de
-->
textos.
-->
Si alto seguido está una
-->
parte de código, esa parte de
-->
código que está ahí, lo que
-->
tiene es lo siguiente.
-->
Hay unos códigos que están
-->
prestalecidos que tú puedes
-->
usar. Esos códigos están
-->
escritos en Java.
-->
¿A dónde quiero llegar con
-->
ese código?
-->
Tú puedes agregar código
-->
necesariamente con Java para
-->
usar en este, en algún
-->
componente o algún job.
-->
Yo le soy sincero, yo no
-->
he hecho, nunca me he puesto a,
-->
aunque no es complicado,
-->
claro, nunca me he puesto a
-->
crear código porque al final
-->
yo creo que me desgasto más
-->
en hacer ese código ahí y
-->
darlo en el formato en que
-->
está, en que requiere, que
-->
he definido como un componente
-->
particular de en el job.
-->
Listo.
-->
Pero digamos que tú quieres
-->
usar un código en EBSES,
-->
lo puedes agregar ahí.
-->
Por aquí viene algo
-->
interesante que se llama los
-->
SQL templates.
-->
Y ese SQL templates nota
-->
que hay una carpeta
-->
solamente para clasificar y
-->
cada carpeta tiene diferentes
-->
nombres a nivel de motores
-->
de bases de datos, ¿Cierto?
-->
Ahí tienes, por ejemplo, un
-->
postware, tienes un MySQL,
-->
tienes un Hive.
-->
Eso al final, ¿Para qué es?
-->
Ese templates SQL es para
-->
crear, por ejemplo, un
-->
patrón SQL que tú quieras
-->
ejecutarlo.
-->
Te explico mejor con un
-->
ejemplo práctico.
-->
Me parece mucho mejor.
-->
Permíteme y te muestro
-->
algo aquí que hice hace tiempo
-->
sobre esta herramienta.
-->
Listo, voy por acá.
-->
Un momento, por favor.
-->
Espérate que no lo encuentro.
-->
Ya, se me perdió ese ejemplo.
-->
Sí, aquí lo encontré perfecto.
-->
Este template que está aquí.
-->
Este es un template que hace
-->
lo siguiente.
-->
Hace una consulta SQL sobre
-->
diferentes tablas y al final
-->
hace unos cálculos que van a
-->
ir hacia un data warehouse.
-->
Eso es lo que hace eso que
-->
estoy mostrando aquí.
-->
Y tú pensarás, ¿Por qué no
-->
hiciste eso con componentes
-->
propios del ETL?
-->
Porque en realidad para la
-->
cantidad de tablas era más
-->
eficiente que hubiese hecho
-->
esta codificación y se
-->
ejecutara contra el motor que
-->
si lo hubiese hecho
-->
directamente con la herramienta
-->
ETL.
-->
Entonces, al final, ¿Qué es?
-->
Tú puedes crear unos templates
-->
SQL donde tú vas a escribir
-->
código, velo como un
-->
procedimiento almacenado que
-->
puedes ejecutar contra el
-->
motor de base datos.
-->
¿Y por qué están
-->
diferentes carpetas?
-->
Porque entenderás que cada
-->
motor tiene una sintaxis y
-->
una forma en que puedes
-->
crear y escribir esos
-->
procedimientos almacenados.
-->
Entonces, para eso es que
-->
son esos SQL templates.
-->
Eso es ya muy particular y
-->
muy específico.
-->
Normalmente uno lo hace a
-->
nivel de eficiencia.
-->
Aquí viene algo que vamos a
-->
trabajar que es la parte de
-->
metadata.
-->
Nota que esa metadata hay
-->
muchos tipos de datos.
-->
Entonces, tú como el ETL se
-->
basa en que tú puedas
-->
acceder a fuentes de
-->
datos.
-->
Entonces, tú puedes tomar
-->
esta metadata para tomar,
-->
como su nombre lo dice, la
-->
metadata de los archivos
-->
con que vas a trabajar.
-->
Básicamente, ¿Qué sería la
-->
metadata?
-->
Supongamos que tú tengas un
-->
archivo CSV.
-->
Lo que hace esta metadata es
-->
que te guarda, por ejemplo,
-->
los nombres y el orden que
-->
tienen las columnas en ese
-->
archivo.
-->
Pero lo que hace eso nada
-->
más es guardar esa metadata.
-->
No te guarda los datos del
-->
archivo.
-->
Acto seguido, por aquí
-->
tienes algo que se llama
-->
documentación.
-->
Que esa documentación tú
-->
puede hacer varias cosas.
-->
Puedes, por ejemplo, tener
-->
archivos o manuales de
-->
referencia que puedas
-->
agregar, donde haya algunas
-->
definiciones que te puedan
-->
servir para utilizarte
-->
pronto en el diario de vivir
-->
de tu job.
-->
O en su defecto, en esa
-->
documentación, te van a
-->
quedar, la remedia te permite
-->
cuando tú hagas un job que
-->
te haga una documentación.
-->
Prácticamente lo que te
-->
hace es un archivo HTML que
-->
te explica qué está
-->
haciendo ese job en
-->
particular.
-->
Y por último estaría
-->
pues aquí lo que digamos
-->
que la parte de la
-->
basura, se me escapó el, la,
-->
el bote, llaman a alguno,
-->
bote de basura aquí de donde
-->
van a tener aquí los
-->
elementos que vayan borrando.
-->
Papelera reciclable, claro,
-->
se me escapó el concepto.
-->
Listo, entonces, eso sería
-->
de forma general y voy a ir
-->
explicando.
-->
Inicialmente no voy a
-->
empezar con Big Data porque
-->
claro, en la, en la forma
-->
de que veníamos anteriormente
-->
ya no teníamos una
-->
experiencia sobre una
-->
herramienta que se llama el
-->
Talent Data Integration.
-->
Entonces tú podías ir
-->
directamente a los componentes
-->
de Talent, Talent Big Data y
-->
lo entendías muy
-->
fácilmente, pero entonces
-->
voy a hacer una pequeña
-->
introducción para que
-->
entiendas cómo funciona la
-->
herramienta ETL de Talent.
-->
Esto da lo mismo que uses
-->
Open Big Data, por ejemplo,
-->
Open Data Integration o Open
-->
SB.
-->
Al final el modelo de
-->
funcionamiento es el
-->
mismo.
-->
Para hacer esto entonces
-->
todo me acompaña ahora sí en
-->
lo siguiente.
-->
Voy a ir muy despacio.
-->
Listo, vayamos a y nos
-->
ubicamos en la parte de
-->
repositorio.
-->
Vamos donde dice Job Design,
-->
por favor.
-->
Vamos a darle ahí click
-->
derecho y vamos a crear
-->
aquí un folder.
-->
Te aconsejo como buena
-->
práctica que organizes
-->
tu job dependiendo del
-->
proyecto o digamos varia en
-->
que estás trabajando.
-->
En este caso voy a crear un
-->
job, un folder, perdón.
-->
Crear un folder y lo vamos a
-->
llamar AXA, por favor, AXA.
-->
Listo.
-->
Ahora dentro de AXA vamos a
-->
crear una subcarpeta y esta
-->
lo voy a llamar básicos, o
-->
sea ejemplos básicos.
-->
Vamos a colocar ahí y ya lo
-->
de Big Data lo voy colocando
-->
entonces en algo un poco
-->
diferente, una carpeta
-->
diferente.
-->
Entonces vamos a darle aquí
-->
Finish y lo que he hecho hasta
-->
el momento es crear una
-->
carpeta.
-->
Listo, perfecto.
-->
Ahora se sitúa en la carpeta
-->
básicos, por favor.
-->
Y tan amable.
-->
Y vamos a darle click derecho
-->
por favor ahí y dele
-->
entonces y vamos a darle
-->
crear job, por favor.
-->
Esto es algo que te vas a
-->
conseguir en la mayor parte
-->
de job que es bajo el
-->
ecosistema de talent.
-->
Te pregunta más o menos lo
-->
mismo.
-->
Entonces primero te pregunta
-->
el nombre del job.
-->
Listo.
-->
En este caso vamos a votar
-->
los nombres de job snake case.
-->
Voy a llamar de la siguiente
-->
forma el primer job.
-->
Voy a llamarle job.
-->
Aquí voy a llamar job
-->
underscore transformaciones
-->
underscore básicas.
-->
Sería interesante como buena
-->
práctica en que puedas
-->
completar el propósito del
-->
job y la descripción del job.
-->
Velo del punto de vista en
-->
que aunque tú hagas el job
-->
sabes que ese job tú lo
-->
entiendes pero verlo en que
-->
seguramente pues no siempre
-->
todos vamos a estar en la
-->
misma empresa siempre y
-->
sería bueno entonces para
-->
que documentar el job para
-->
que sea mucho más sensible
-->
pues hacer cualquier
-->
mantenimiento que tenga
-->
sobre ese job como tal.
-->
Propósito del job voy a
-->
colocar aquí explorar los
-->
elementos básicos de la
-->
herramienta de tal en mi data
-->
de la herramienta de explorar
-->
los elementos básicos de la
-->
herramienta de vamos a
-->
colocar aquí como
-->
descripción vamos a colocar
-->
aquí el job leerá leerá
-->
unos archivos de entrada y
-->
salidos formateará formateará
-->
formateará a un archivo de
-->
salida diferente.
-->
Diferente. Esto lo voy a
-->
hacer solamente en este eh en
-->
este job, es decir, eh los
-->
demás yo no voy a agregar
-->
propósito ni descripción
-->
porque me de casta mucho en
-->
el tiempo y en realidad
-->
tengo un poco tiempo para
-->
la cantidad de elementos que
-->
tengo. Si notas ahí te
-->
pregunta otras cositas como el
-->
autor y el bloqueador. Ese
-->
autor y bloqueador en esta
-->
versión carecen un poco de
-->
significado pero ese autor
-->
ese autor que aparece ahí
-->
cuando tengas eh ya el
-->
sistema montado te había
-->
comentado en una clase que
-->
hay eh cuando yo tengo ya
-->
licenciado el talen hay
-->
una herramienta que se
-->
llama el talen MC el Manas
-->
console el Manas console
-->
maneja los usuarios entonces
-->
ahí por defecto como tú te
-->
vas a loguiar con el TMC en
-->
el autor te va a aparecer el
-->
autor que te haya creado el
-->
administrador de talen y en el
-->
bloqueador pasa lo siguiente
-->
el bloqueador que es
-->
normalmente el que crea el
-->
job eh es el que permite
-->
bloquear entonces el
-->
bloqueador que quiere decir
-->
hombre que muchas veces tú
-->
puedes darles permisos a un
-->
grupo de usuario para que
-->
puedan digamos escribir o
-->
modificar el job y hay
-->
algunos que lo puedan
-->
bloquear para eso es que
-->
sirve el bloqueador ese que
-->
está ahí ahora las versiones
-->
son eh netamente internas
-->
estas versiones eh el caso
-->
de la herramienta no no sé
-->
si solamente a modo
-->
informativo notarás entonces
-->
que a nivel de versiones
-->
se manejan algunos manejan
-->
tres números maneja entonces
-->
el número que llaman el
-->
mayor el número que llaman
-->
el minor y el número que
-->
llaman el el patch entonces
-->
si yo tengo por ejemplo
-->
versión diez punto dos punto
-->
tres y paso a diez por
-->
ejemplo a diez punto cuatro
-->
como estoy en el patch el
-->
que subí el patch significa
-->
en que lo que he hecho es
-->
corregir algún error que
-->
tengo si por ejemplo yo
-->
paso de versión ahora a
-->
versión diez punto tres
-->
punto cuatro subí el minor
-->
significa que no es que haya
-->
agregado una nueva
-->
funcionalidad sino pude haber
-->
hecho una refatorización
-->
del código para que sea más
-->
entendible para que sea más
-->
eficiente pero sigue
-->
funcionando y todavía sigue
-->
siendo compatible el problema
-->
tengo con el mayor que es
-->
por ejemplo si yo paso a
-->
once punto tres punto cuatro
-->
hay una característica que
-->
se busca pero el once cuando
-->
yo subo el mayor no hay
-->
garantía de que siga
-->
funcionando con versiones
-->
antiguas eh eh al subir de
-->
versión no significa no no
-->
significa o no es prioridad o
-->
digamos no es garantía si
-->
subo el mayor de que te siga
-->
funcionando el código tuyo
-->
cuando sube la versión son
-->
características eh pasa y
-->
te pongo un ejemplo muy
-->
claro con ah php php que ya
-->
hace rato no trabaja con
-->
php eh php con ocho y con
-->
siete epa me tocó
-->
refactorizar eh reescribir
-->
mucho código para adaptarlo
-->
a la versión ocho porque
-->
hay cosas que no estaban
-->
funcionando bien entonces
-->
por qué porque subió el mayor
-->
entonces esta parte que está
-->
aquí la m minúscula lo que
-->
te hace nada más tengo mayor
-->
y minor entonces la m minúscula
-->
si yo cojo aquí m minúscula
-->
me sube el minor y m
-->
mayúscula me sube el mayor
-->
entonces si yo subo a
-->
versión uno punto cero por
-->
estandarización significa
-->
que he creado la versión la
-->
primera versión estándar ya
-->
el sistema versión ya tú lo
-->
manejas internamente lo que
-->
si es seguro es que la
-->
herramienta eh como es open
-->
source no te permite bajar
-->
los modificarlos si ya lo
-->
subiste si lo subiste al uno
-->
ahí no te deja bajar lo tengo
-->
que ya pues cancelar el yoke
-->
y volverlo a crear nuevamente
-->
por aquí eh el estado eh tú
-->
puedes manejar estado que eh
-->
developer texting y producción
-->
ahí tienes que manejar
-->
internamente cómo vas eh como
-->
tu equipo de trabajo desarrollo
-->
ETL va a manejar esta parte
-->
de texting cuando pasa un
-->
texting a digamos a a cuando
-->
un devolven perdón cuando
-->
un devolven pasa a testing o
-->
sea cua cuando de cua pasa
-->
a producción bueno etcétera
-->
ahí ya la cantidad de cosas
-->
vamos a colocar aquí
-->
development y el pad pues el
-->
pad aquí lo que me está
-->
identificando es donde a nivel
-->
local lo voy a guardar este
-->
archivo ya en la versión
-->
comercial lo que hace este
-->
pack es que te guarda en el
-->
repositorio aquí que tengas
-->
interno eh a nivel local y
-->
te guarda eh repositorio
-->
centralizado que tengas de
-->
aquí listo eso es nada más
-->
la entrada es más que todo
-->
y ahí tienes la información
-->
informativa de esta parte
-->
dale por favor finish
-->
perfecto y se te abre una
-->
nueva perspectiva esta
-->
perspectiva que está aquí en
-->
el centro es lo que uno llama
-->
el canvas en ese canvas es
-->
que vas a colocar los
-->
diferentes componentes del
-->
job como tal de igual forma
-->
se te abre una una una
-->
pestaña una perspectiva en
-->
la parte de abajo que te
-->
va a permitir configurar
-->
ciertos elementos del job y
-->
tienes una perspectiva que
-->
está aquí a la izquierda que
-->
te va a permitir configurar
-->
algunos elementos a nivel de
-->
código de ese job y la
-->
perspectiva que tiene acá
-->
de la parte derecha que son
-->
las paletas son los
-->
diferentes componentes que
-->
vas a que puedes usar
-->
dentro de un job y están
-->
clasificados ve aquí te
-->
clasifica como big data
-->
business intelligent bueno
-->
cloud aclaro que a nivel
-->
comercial te van a aparecer
-->
más de lo que están aquí
-->
en el centro de la
-->
profesional. Bueno vamos a
-->
crear nuestro primer job
-->
para ver para decirle cómo
-->
funciona esta parte. Primero
-->
vamos entonces a definir una
-->
metadata es decir quiero leer
-->
un archivo de entrada y
-->
para leer un archivo de
-->
entrada necesito saber la
-->
estructura del archivo por
-->
si acaso la herramienta está
-->
más pensada los componentes
-->
están pensados para que haga
-->
un procesamiento estructurado
-->
pero si vas a agregar un
-->
procedimiento no estructurado
-->
entonces hay unos componentes
-->
que te van a permitir
-->
codificar por ejemplo leer
-->
datos de un audio leer
-->
datos de un archivo PDF
-->
convertirlo si lo hay
-->
pero las principales
-->
componentes que existen
-->
están pensados para
-->
elementos netamente
-->
estructurados. Esta
-->
metadata que está aquí
-->
entonces hagamos lo
-->
siguiente expande por favor
-->
el menú de metadata si
-->
está más grande. Y ahora
-->
hagamos lo siguiente quiero
-->
leer un archivo en un formato
-->
específico resulta que él te
-->
va a clasificar los archivos
-->
dependiendo del formato en
-->
que lo vas a leer entonces
-->
aquí notarás en que tú
-->
puedes leer tablas de una
-->
base de datos en DB
-->
connection tienes archivos
-->
delimitados tienes archivos
-->
estos archivos delimitados
-->
lo que hace es que delimita
-->
por un ancho por ejemplo yo
-->
quiero delimitar los datos
-->
que van del cero al diez al
-->
carácter diez del once al
-->
veinte y delimita por
-->
digamos un índice o un
-->
espacio los delimitados
-->
son los SV eh estos
-->
posicionales perdón el
-->
delimitado perdón el
-->
delimitado son los SV que
-->
están delimitados por un
-->
carácter los posicionales
-->
son los que te dicen qué
-->
posición de la cero a la
-->
diez del once al veinte y
-->
así sigue sucesivamente
-->
y si te preguntas si hay un
-->
metadata que quiero leer y
-->
no está dentro de esto de
-->
dentro de elementos que
-->
están por defecto tiene
-->
varias opciones una opción
-->
es buscar el repositorio
-->
para ver el repositorio de
-->
talent en las últimas
-->
versiones para ver si le
-->
agregó un metadata de esa
-->
forma o en lo último le
-->
tocaría hacer una
-->
programación me explico
-->
supongamos que quieras
-->
leer un PDF y el PDF no
-->
está aquí entonces podía
-->
ver si existe un componente
-->
que tiene un PDF si el
-->
componente no está en los
-->
que están actualizados
-->
hoy en día lo que puedes
-->
hacer es que creas un
-->
código aquí por ejemplo en
-->
bueno necesariamente en
-->
Java en que tome el
-->
fichero y lea los datos
-->
si no existe la metadata
-->
como el archivo que quiero
-->
leer es un archivo CSV
-->
entonces los archivos
-->
SV se encuentran en
-->
formato que llaman del
-->
limitado este que está
-->
dele clic derecho por
-->
favor a este señor y
-->
coja la opción crear file
-->
delimited y te va a
-->
aparecer un conjunto de
-->
opciones note ahora que
-->
sigue la misma tendencia a
-->
nivel de los elementos de
-->
metadata que son
-->
parecidos al yo te va a
-->
parecer el autor
-->
bloqueador versión etcétera
-->
ya tú tienes que ver
-->
internamente cómo
-->
conjugas esta parte en
-->
los estándares de
-->
desarrollo que tengas ya
-->
en tu empresa pero aquí no
-->
voy a crear ya más
-->
propósito de descripción
-->
ni tampoco voy a crear
-->
versión por una
-->
cuestión netamente de
-->
tiempo aquí voy a llamar
-->
entonces sería buena
-->
práctica que llamaras el
-->
archivo de igual forma
-->
que que el formato en que
-->
está en este caso quiero
-->
leer un archivo que se
-->
llama generos generos
-->
generos generos sería
-->
buena práctica que
-->
colocaras la fecha de
-->
esa versión que tengas en
-->
el mismo nombre o en el
-->
propósito pero bueno no
-->
lo voy a hacer por una
-->
cuestión netamente de
-->
tiempo dejamos solamente
-->
generos y vayamos aquí
-->
donde dicen next bien por
-->
defecto estos metadatos
-->
vienen con una
-->
característica en que van
-->
a buscar esos datos o
-->
esos archivos a nivel
-->
local o a nivel o a
-->
nivel local en el equipo
-->
o en la versión en la
-->
versión comercial puede
-->
hacerlo a nivel de redes
-->
o sea puede tener una
-->
carpeta compartida en la
-->
cual vas a ver en este
-->
caso vamos aquí donde
-->
dice bros y se va entonces
-->
a la carpeta que se llama
-->
en el escritorio recursos
-->
entra a su carpeta de de
-->
tal en mi data entra donde
-->
dice data set y accede a
-->
donde dice ccv note que
-->
ahí está un archivo que
-->
se llama gen repunto ccv
-->
por favor tómelo
-->
de quién me habló Beatriz o
-->
Brenda voy a su máquina
-->
por ah listo en primer
-->
día es donde está voy a voy
-->
a su pantalla ahí primero
-->
vamos a colocar el nombre
-->
del metadata llámelo
-->
generos por favor si están
-->
amables dele next por
-->
favor y ahora váyase a
-->
dice bros por favor ahí
-->
donde dice fichero sitúese
-->
en el escritorio ahí está
-->
recursos tbd la primera
-->
carpeta tbd data set cv y
-->
escoja que no lo cojo dele
-->
nuevamente clic en el segundo
-->
no no no no cojo el clic ahí
-->
listo y dele abrir por
-->
favor bien continúa entonces
-->
eh bueno aquí podía seguir
-->
con los detalles pero hay
-->
detalles que lo voy a
-->
enviar porque pronto por
-->
tiempo bueno aquí solamente
-->
note que aquí hay un
-->
formato porque este formato
-->
hay que tenerlo en cuenta
-->
lo que pasa es que este
-->
formato lo que tiene en
-->
cuenta son los caracteres de
-->
tabulación y de salto de
-->
línea entonces el carácter
-->
de salto de línea a nivel
-->
de lo que es windows es el
-->
mismo que el de unis pero
-->
puede que el de mac el
-->
carácter de salto de línea
-->
sea diferente recordará que
-->
cuando yo tengo un archivo
-->
yo en cada línea tengo un
-->
carácter que hace que
-->
el carácter de salto de
-->
línea para que entienda el
-->
sistema operativo que hay
-->
que bajar entonces aquí la
-->
recomendación es la siguiente
-->
si está trabajando en un
-->
sistema windows o un sistema
-->
unis no hay problema pero
-->
pronto mac sería
-->
recomendable que usaras
-->
aquí mac entonces aquí puedo
-->
usar unis porque el de
-->
unis sigue siendo el mismo
-->
de windows entonces no hay
-->
mucho problema a nivel de
-->
tabulación y salto de línea
-->
aquí me da un preview de
-->
los datos que están vamos
-->
y por aquí están algunas
-->
características que te voy a
-->
dar recomendación en primer
-->
lugar está el sistema de
-->
codificación aquí te
-->
recomendaría que el sistema
-->
de codificación en el caso
-->
de nuestro idioma que es el
-->
español y tiene unos
-->
caracteres especiales ese
-->
ASCII no te va a funcionar
-->
bien cuando es español
-->
porque porque los
-->
caracteres especiales como
-->
la ñ y la tilde te lo
-->
va a marcar con no lo va
-->
a entender entonces yo te
-->
aconsejo en su defecto que
-->
no te va a cambiar si no usas
-->
dos tipos de de codificación
-->
o usen su defecto UTF 8 o en
-->
su defecto Windows 12 52
-->
entonces aquí no hay mucho
-->
problema con el ASCII porque
-->
los datos están en inglés
-->
pero acostúmate a usar UTF
-->
8 mejor y ahora eso como
-->
recomendación no te va a
-->
cambiar y ahora pasa lo
-->
siguiente analiza que el
-->
carácter de separación que
-->
tengo el CSV es coma y por
-->
ejemplo este defecto aquí en
-->
el separador de campo está
-->
punto y coma entonces dale
-->
aquí clic y escoge el
-->
carácter de separación si
-->
no está ahí hay una opción
-->
que dice custom que puedes
-->
escoger el carácter que no
-->
está aquí tengo la coma y
-->
escojo coma por favor. Nota
-->
también que aquí en el preview
-->
que tengo tengo unos
-->
encabezados que dice Jim
-->
Rayde y Ney pero él me
-->
colocó un encabezado que
-->
dice columna cero porque si
-->
sabe que tu archivo tiene
-->
encabezado por favor chulea
-->
aquí donde dice y ya después
-->
que tiene la configuración
-->
dale un refresh y ese
-->
refresh te va a mostrar los
-->
datos con la configuración
-->
correcto no sé si hay
-->
alguien que va a comentar
-->
algo. Ese refresh que está
-->
ahí muy ojo lo siguiente ese
-->
refresh lo que hace ahí
-->
es que toma del archivo
-->
que tiene 50 filas tú puedes
-->
cambiar el preview ese que
-->
tiene ahí ese preview que
-->
está aquí son 50 filas
-->
nada más nada más el archivo
-->
tiene 25 pero viene un preview
-->
por defecto a 50 tú puedes
-->
cambiar eso que está ahí
-->
cómo te afecta el preview ya
-->
te digo que te afecta el
-->
preview esto es lo mismo que
-->
el talent data preparation
-->
ya te digo en qué te
-->
afecta ve entonces ya después
-->
que mira visualmente que
-->
tu archivo está estructurado
-->
de forma correcta vemos que
-->
tenemos dos columnas
-->
estructuradas de forma
-->
correcta vayamos aquí donde
-->
dice next
-->
nota que el archivo es formato
-->
ccv recordará que los ccv
-->
no guardan tipo de datos el
-->
ccv solamente guarda los
-->
datos ahora nota que la
-->
herramienta te está
-->
mostrando aquí la estructura
-->
que es gen raide y ney lo
-->
como como columna pero le
-->
ha colocado un tipo de
-->
datos que es integer y
-->
stream de dónde saca eso
-->
bueno lo que hace eso es
-->
que a partir del preview
-->
que tiene mide a los datos
-->
analiza y proyecta qué tipo
-->
debería ser como el primero
-->
era numérico proyectó para
-->
que sean integer como el
-->
segundo tenía puro texto
-->
entonces proyectó a stream
-->
tienes que tener en cuenta
-->
que esto lo hace el preview
-->
por ende puede haber un
-->
error porque quizás en la
-->
línea cincuenta y uno en la
-->
fila cincuenta y uno hay
-->
una letra entonces lo
-->
clasificó como integer y
-->
en realidad que era una
-->
letra entonces ahí tiene
-->
que estar muy pendiente que
-->
puede haber un error en la
-->
clasificación por la forma
-->
en que él internamente lo
-->
clasifica ese integer y
-->
stream son tipos de datos
-->
de java entonces de aquí
-->
finish y automáticamente
-->
lo que hace es que en la
-->
metadata te crea aquí un
-->
árbol y te muestra el
-->
archivo generado voy a
-->
borrar este que tengo
-->
aquí de ejemplo bueno aquí
-->
tengo uno de que como que
-->
estaba haciendo alguna
-->
prueba y lo dejé ahí bueno
-->
y ya está listo entonces
-->
sigamos la herramienta de
-->
tel está empezada para como
-->
su nombre dice extraer es
-->
decir leer de fuentes de
-->
entrada transformar los
-->
datos y cargarlos a una
-->
fuente diferente o a la
-->
misma fuente en este caso
-->
me piden que quiero leer
-->
como tal los datos de ese
-->
archivo entonces hay
-->
diferentes formas de hacer
-->
lo mismo voy a empezar con
-->
la primera la primera es
-->
la más fácil quiero leer
-->
los datos que están en este
-->
archivo que está géneros
-->
está claro que el tal en no
-->
te guarda en este punto no
-->
te guarda los datos del
-->
archivo lo que te guardas
-->
la metadata o sea pocas
-->
palabras los datos de las
-->
columnas y en qué orden
-->
están toma ahora este
-->
género le da lo selecciona
-->
aquí sostenidos y lo vas a
-->
soltar en el canvas suéltalo
-->
acá y ahí lo que te va a
-->
mostrar son diferentes
-->
componentes con el cual el
-->
tal en detento que puedes
-->
procesar esos datos en la
-->
mayor parte de los casos el
-->
componente que está por
-->
defecto es el componente
-->
ideal para la metadata que
-->
escogiste des cuenta que por
-->
defecto aparece te file
-->
input delímite entonces para
-->
aprendernos algo de tal en
-->
los componentes de tal en la
-->
mayoría empiezan en te te
-->
minúscula de tal en si
-->
tiene el el si contiene la
-->
palabra input significa que
-->
va a ser de entrada así que
-->
que voy a leer si tiene output
-->
significa que es de salida
-->
significa lo siguiente te
-->
file input delímite voy a
-->
leer un archivo de entrada
-->
de tipo ccv y tú dices y
-->
cómo convierto eso un
-->
archivo es decir cómo
-->
escribo un archivo de
-->
salida delímite entonces va
-->
a buscar ya un componente
-->
que es te file output de
-->
límite entonces está muy
-->
parecido el mismo nombre
-->
lo que te va a cambiar es
-->
el input o output en su
-->
efecto como ese es el que
-->
más conviene vamos a darle
-->
aquí ok perfecto
-->
darle clic en el componente
-->
que agregamos y nota que
-->
la perspectiva de abajo
-->
más específicamente en la
-->
pestaña de componente te
-->
da unas pequeñas
-->
características de ese
-->
componente la mayoría de
-->
componentes tienen estas
-->
cinco configuraciones basic
-->
avance dinámica y
-->
documentation vamos a tratar
-->
en no voy a entrar tan en
-->
detalle porque voy a
-->
oprimos de haciendo el
-->
detalle y pierdo mucho
-->
tiempo pero si tiene alguna
-->
duda por favor y me la
-->
avisa yo en pronto en en
-->
otro espacio diferente nos
-->
podemos conectar yo le
-->
explico cualquier cosa listo
-->
aquí tengo un componente
-->
de entrada ahora quiero
-->
formatear este componente
-->
entonces la herramienta
-->
tiene diferentes
-->
componentes para formatear
-->
listo voy a usar voy a
-->
colocar el más usado para
-->
agregar un componente en el
-->
canvas ya ve que la primera
-->
forma es tomar el metadata
-->
y soltarlo aquí para
-->
agregar un componente
-->
diferente ahora voy a
-->
hacerlo de esta manera voy
-->
a escribir el nombre del
-->
componente yo te voy a
-->
entregar a ti una
-->
documentación donde están
-->
los diferentes componentes
-->
de ya de talent creo que
-->
parece carece de sentido en
-->
que yo haga una diapositiva
-->
y te explique componente
-->
por componente porque
-->
perdemos ahí no alcanzamos
-->
las seis horas del día
-->
de hoy para aplicar de
-->
todos los componentes que
-->
tienen entonces te voy a
-->
tratar de colocar los
-->
componentes que más
-->
requieres ahora vamos a
-->
agregar el siguiente cómo
-->
así estando aquí en el
-->
canvas darle clic aquí en
-->
el canvas vamos a buscar
-->
un componente que se
-->
llama tema más de mapeo
-->
entonces empieza con té y
-->
hazte cuenta que te
-->
aparece un menú una lista
-->
incremental de los
-->
componentes que empiezan
-->
con té dale ahora eme y
-->
empieza a colocar los
-->
componentes que empiezan
-->
por té eme una lista
-->
incremental en este caso
-->
me interesa ese tema que
-->
está ahí que estoy
-->
buscando le puede dar enter
-->
o le puede dar clic yo le
-->
di enter y me trae el
-->
componente la otra forma
-->
que tú puedes agregar un
-->
componente entonces aquí
-->
al canvas ya te dije ya
-->
me fui de la metadata
-->
hasta acá ya creé uno
-->
aquí en el centro la otra
-->
sería la siguiente que lo
-->
vamos a buscar en esta
-->
paleta entonces esta
-->
paleta tiene aquí un un
-->
buscador vamos a colocar
-->
lo siguiente vamos a
-->
colocar la palabra loc de
-->
bitácora log log enter
-->
y hace una búsqueda de
-->
loc trajo muchos archivos
-->
entonces por favor
-->
colócale mejor un té loc
-->
colócale té loc mejor
-->
para que eh disminuya la
-->
cantidad de de componentes
-->
que tenía un loc
-->
colócale té loc enter té loc
-->
enter y hay varios
-->
componentes para poder
-->
hacer digamos auditorías
-->
uno de los más usados es
-->
este té loc rob
-->
té loc rob normalmente es
-->
un componente que hago a
-->
nivel de developer o sea
-->
perdón inversión de
-->
desarrollo inversión de
-->
desarrollo en el que estoy
-->
probando y seguramente ya
-->
en versión de producción
-->
ya que después que está
-->
testiado ya quitas esos
-->
té loc rob que utilizaste
-->
para ser mucho más
-->
eficiente tu tu job
-->
entonces a nivel de de de
-->
developer o de del entorno
-->
de developer mientras
-->
desarrollo voy a usar este
-->
té loc rob para probar lo
-->
como los elementos que vaya
-->
agregando en el té loc en el
-->
en el canvas para agregar
-->
este señor toma el té loc
-->
rob clic sostenido y lo
-->
sueltas aquí en la canva
-->
sí sí
-->
me sacó ah ah ya eh porque
-->
hay una etapa hay una
-->
etapa en el entorno
-->
intermedio que es Cuba en
-->
Cuba eh debería reflejar
-->
exactamente lo que está en
-->
producción aclaro la palabra
-->
debería pero en la vida real
-->
no es así en el en la vida
-->
real no están así entonces
-->
en realidad eso me
-->
quedarían en Cuba donde si
-->
hay un error lo replico
-->
en Cuba y verifico para ver
-->
cuál es y ya a nivel de
-->
producción eso no deberían
-->
estar aclaro que esto en
-->
un mundo ideal eh a veces
-->
un mundo ideal no está en
-->
en el en las empresas que yo
-->
he trabajado a veces producción
-->
va va más arriba que Cuba
-->
sí eh en el mundo ideal
-->
sería así pero la pregunta es
-->
interesante porque a veces la
-->
teoría no cuadra con con la
-->
vida real a veces a a a
-->
solo nos tocó un error que
-->
había pero el error era
-->
habitada para un cliente
-->
entonces corrimos el riesgo
-->
de corregirlo en producción
-->
y entonces ahí producción
-->
se nos fue más adelante que
-->
en la vida real en Cuba
-->
¿Por qué? Porque era vital
-->
ese cliente no sabía que
-->
corregir un pequeño problema
-->
ahí la teoría pues no se
-->
aplicó como debería pero a
-->
final no se no se podía
-->
perder el cliente. Listo
-->
entonces ya tenemos los
-->
componentes esto que
-->
necesitamos entonces este
-->
componente de géneros que
-->
está aquí es un componente
-->
de entrada que vale los
-->
datos que tiene el archivo
-->
géneros tema va a mapear
-->
y Telo me va a escribir los
-->
datos entonces en consola
-->
ahora vamos a lo siguiente
-->
ahora vamos a unir este
-->
señor con este tema listo
-->
hay diferentes formas de
-->
unirlo me voy a lo más
-->
básico entonces la primera
-->
forma de unirlo es la
-->
siguiente le da clic derecho
-->
sobre el componente que
-->
vas a unir clic derecho y
-->
aquí te aparecen dos
-->
opciones una opción que
-->
dice fila y disparadores
-->
vamos a coger donde dice
-->
fila escojamos aquí main
-->
te aparece por defecto una
-->
flecha y coloca esa flecha
-->
en el centro del componente
-->
que vas a unir y te aparece
-->
ahí y te conecta ya te lo
-->
hace la unión ahí perdón
-->
aquí se me fue la lista
-->
claro como no listo ya
-->
aquí encontró seta escoja
-->
el componente que voy a
-->
conectar con el con el
-->
otro que sería el género
-->
va a contarlo con el tema
-->
le voy a clic derecho en
-->
géneros y de aparecerme un
-->
menú en el menú voy a
-->
entrarle que se dice fila y
-->
voy a escoger la opción main
-->
me debería ahora crear una
-->
flecha y esa flecha la voy
-->
a conectar al centro del
-->
gráfico o el icon del
-->
componente que doy clic
-->
aquí sí ya vamos entonces
-->
vamos a hacerlo entonces de
-->
esa forma que el nombre la
-->
flecha viene de esta
-->
manera listo ya digo vamos
-->
a unir ahora este tema con
-->
este teló ro entonces vamos
-->
a unirlo de forma diferente
-->
dele clic en el componente
-->
del tema y note que ahí le
-->
aparece una flechita en
-->
naranja hay algunos que le
-->
gustan y parece engorrosa
-->
esta forma pero como esta
-->
flechita aquí y la suelta
-->
en el teló ro ahora hay
-->
unas uniones de componentes
-->
dentro del talent que te
-->
exige que le coloques un
-->
nombre a la conexión
-->
entonces aquí lo que voy a
-->
hacer es lo siguiente
-->
partiendo que el map va a
-->
formatear la salida voy a
-->
colocarle lo siguiente salida
-->
on the record formateada y
-->
eso me ayuda a leer de forma
-->
más transparente el flujo de
-->
mi proceso sería conveniente
-->
en que le llegue a sus
-->
nombres a los diferentes
-->
flujos para que cualquier
-->
persona que lea tu yo pues
-->
lo pueda entender
-->
conecta por favor como tú
-->
quieras y si desea conectan
-->
clic derecho o como
-->
ustedes quieran me gusta más
-->
clic derecho y le doy fila me
-->
parece mucho más sencillo se
-->
llama salida on the record
-->
formateada nota que en el
-->
caso particular de la unión
-->
de géneros con más no te
-->
pidió el nombre pero sería
-->
interesante en que a esos
-->
flujos le diga sus nombres
-->
concretos de lo que hace
-->
entonces en el caso de ese
-->
road uno que está ahí
-->
entonces vamos a cambiarle un
-->
poco el nombre de road uno
-->
cómo se cambia ese road uno
-->
vamos a darle dos clic no
-->
doble clic sino dos clic
-->
primer clic voy a darle clic
-->
en road uno road uno aquí
-->
después le doy otra vez
-->
clic y me abre para cambiar
-->
el nombre no es doble clic
-->
sino dos clic primero un
-->
clic y después el siguiente
-->
clic lo voy a llamar géneros
-->
on the record datos
-->
claro que esta es la
-->
parte básica del talen ya
-->
no me voy a meter con bit
-->
data espero no demorar mucho
-->
con esto pero esto es
-->
primordial para que pueda
-->
entender lo que vamos a
-->
hacer
-->
note otra característica de
-->
la opción de talen es que
-->
cuando tienes un componente
-->
y el componente tiene un
-->
elemento en rojo del lado
-->
derecho como lo notaste ahí
-->
en el tema ese tema que está
-->
ahí significa que hay un
-->
error o hay o todavía no
-->
has configurado el componente
-->
entonces el problema que
-->
tengo aquí ya por experiencia
-->
y como lo conozco es que
-->
todavía no he configurado el
-->
tema por eso me aparece el
-->
rojo entonces el rojo aparece
-->
o porque hay una mala
-->
configuración o porque todavía
-->
no has configurado el
-->
componente si intentamos
-->
ejecutar con ese rojo pues
-->
no va a ser un error
-->
vamos a darle aquí doble
-->
clic por favor
-->
entonces nota el típico
-->
trabajo de mapeo en el
-->
de la entrada como viene de
-->
la fuente esas variables me
-->
van a permitir formatear los
-->
datos como yo quiera estos
-->
ejemplos lo hago más adelante
-->
y acá tengo la salida que
-->
quiero que salga en ese
-->
caso del formateo
-->
nada más quiero que salga lo
-->
siguiente
-->
toma los archivos que ven a
-->
aquí toma estos elementos
-->
que están acá seleccionados
-->
con control todos control
-->
da control y da clic para
-->
selecciones todos y los
-->
sueltas de este lado
-->
nota que aquí no hay ninguna
-->
transformación solamente lo
-->
que quiero hacer es cambiarle
-->
el nombre a las columnas de
-->
salida nota que aquí tengo
-->
los elementos que entra y
-->
acá tengo los elementos que
-->
salen por defecto la salida
-->
viene de los de los
-->
encabezados vendría con los
-->
mismos nombres de entrada
-->
pero yo quiero cambiarlo en
-->
muchas veces o hay veces
-->
que quiere cambiar los
-->
tipos de datos para cambiar
-->
esto vete acá a la parte de
-->
abajo que hay una tablita le
-->
da clic
-->
en la primera columna que
-->
se llama y en re y le das y
-->
la vas a llamar género
-->
perdón lo va a llamar
-->
identificador
-->
acostumbrate a algo en
-->
esta herramienta eso al
-->
final es un table es un
-->
otro table en java porque
-->
no te ha creado con java el
-->
java tiene un problema un
-->
pequeño boque a veces yo
-->
voy a poner clic por afuera
-->
y a veces no se automatiza
-->
el no se actualiza perdón el
-->
dato acostumbrate que cuando
-->
vayas a cambiar algún table
-->
creo que como buena práctica
-->
darle un enter porque hay
-->
veces que no se actualiza
-->
o sea mejor darle enter que
-->
darle clic por afuera y
-->
cambia el segundo elemento a
-->
nombre enter si bueno va a
-->
colocar la mayúscula
-->
colócalo allá como no
-->
no me califico aquí para
-->
considerarlo de perfecto no
-->
hago ninguna transformación
-->
más aquí voy a darle aquí
-->
ok y es bien cuando tú
-->
tienes un yo recordará que
-->
tú lo que hace gráficamente
-->
unes componentes configuras
-->
componentes y el yo que
-->
internamente tiene que generar
-->
un código esa parte es muy
-->
importante para poder detectar
-->
código más rápidamente y
-->
puede hacer más rápido en la
-->
parte de corrección nota que
-->
aquí en la parte de aquí de
-->
abajo aquí hay una pequeña
-->
pestaña que dice designer y
-->
co dale clic aquí en co por
-->
favor antes por favor guarda
-->
si quieres guarda el por si
-->
acaso y aquí lo que está
-->
dando es como transforma esa
-->
unión de componentes en un
-->
código java que va a
-->
ejecutar después aquí abajito
-->
aquí en la parte de abajo del
-->
del canvas está una
-->
pestañita muy pequeña que
-->
dice designer o co si das co
-->
aquí te va a aparecer el
-->
código generado ah listo
-->
acá en el en el disque este
-->
que está acá aunque por
-->
defecto cada vez que tú
-->
ejecutas es él va a guardar
-->
los el yo esto mismo lo
-->
puedes ver acá en la en la
-->
pestaña de acá abajo que
-->
dice visor de código te va a
-->
mostrar lo mismo yo creo que
-->
me parece mucho más sencillo
-->
aquí en co esto es fundamental
-->
cuando hay unos errores
-->
entonces detectarlos más
-->
rápidamente en qué componentes
-->
que está el error y cuál
-->
error está aquí no aparece
-->
ningún punto rojo este no
-->
aparece ningún punto rojo
-->
indica que no hay ningún
-->
error de codificación en el
-->
componente cuando generó
-->
el el el el el el el el
-->
código ¿Cómo hacemos para
-->
ejecutar esto? Bueno, vaya
-->
forma, la primera la voy a
-->
ejecutar, la más sencilla es
-->
te vas en la toolbar y vas a
-->
tener acá un un play que es
-->
símbolo oficial de ejecutar.
-->
Dale aquí ejecutar.
-->
Entonces, al final lo que
-->
ejecutas el código ya va
-->
generado. Listo, aquí lo que
-->
está haciendo entonces es
-->
que este te lo rojo que es
-->
un elemento para visualizar
-->
datos en consola te está
-->
mostrando cuáles son los
-->
datos que trae ese archivo.
-->
Nada del otro mundo.
-->
Ahí aparte de eso te está
-->
mostrando cuántas filas va
-->
leyendo, cuál es el promedio
-->
de lectura de fila para que
-->
tú puedas darte una idea de
-->
cuánto puede demorarte un
-->
job con base a cuántos
-->
datos tienes. Seguimos
-->
por favor. Qué pena que vaya
-->
un poco más rápido porque
-->
es que sé que me va a
-->
quedar corto el tiempo.
-->
Entonces voy a seguir lo
-->
siguiente. En este mismo
-->
yo voy a leer otro archivo,
-->
¿OK? Para esta parte,
-->
entonces, voy a hacer lo
-->
siguiente. Voy a leer un
-->
archivo en formato XML.
-->
Para esta cuestión voy a
-->
voy aquí a file XML, como
-->
sé qué formato XML, clic
-->
derecho y voy a decir crear
-->
file XML. Este archivo lo
-->
voy a llamar empleados. Voy
-->
a dar aquí next. Y como
-->
todo, hay componentes que
-->
tienen características
-->
diferentes. Entonces, aquí
-->
me pregunta, esto pasa mucho
-->
con los JSON y los XML, si
-->
la metadata que voy a hacer
-->
es de entrada o salida. En
-->
este caso es de entrada
-->
porque voy a leer un
-->
archivo. ¿Para qué sería el
-->
de salida? Para crear un
-->
archivo con ese formato.
-->
Pero como lo que voy a
-->
hacer es voy a leer en
-->
XML, entonces voy a coger
-->
XML entrada. Y ahora voy
-->
a buscar en la carpeta de
-->
recursos, subo a la carpeta
-->
de datos y voy entonces a
-->
XML y ahí aparece un
-->
emplodge XML. File XML. ¿Sí
-->
cogiste file XML? Sí, sí.
-->
Sí, ese emplodge que tienes
-->
ahí, sí, exactamente.
-->
Escojamos este emplodge que
-->
está aquí a abrir. Y me
-->
aparece la estructura del
-->
XML. Vamos a darle aquí
-->
y ahora recordarás, no sé si
-->
de pronto lo tienes claro, es
-->
que cuando yo voy a leer un
-->
archivo o cuando voy a leer
-->
un archivo de XML existe
-->
unos lenguajes. En el caso
-->
particular del señor XML
-->
existe un lenguaje que se
-->
llama XML y el del se llama
-->
JSONPAT. En este caso la
-->
herramienta en particular pasa
-->
a lo siguiente con la
-->
herramienta. La herramienta
-->
usa XMLPAT para XML y usa
-->
JSONPAT para leer JSON.
-->
Listo, entonces no voy a
-->
entrar mucho en detalle de
-->
cómo funcionan los lenguajes
-->
de consulta XML y JSONPAT
-->
que son muy parecidos,
-->
pero básicamente velo de
-->
este punto de vista. Para el
-->
señor JSONPAT, este representa
-->
el el el ROOT, o sea, el
-->
ROOT del archivo, mientras
-->
que para el XML lo menciona
-->
como ROOT así, ROOT así.
-->
Entonces, aquí te pregunta,
-->
oye, ¿De dónde el absolute
-->
PACK, XPACK que está aquí,
-->
que es, ¿De dónde vas a
-->
empezar a leer los archivos?
-->
Como este señor es un
-->
ARRAY, el problema que tengo
-->
no lo hago usted ya, es que si
-->
yo uso como absolute PACK el
-->
ROOT y pongo los datos que
-->
quiero leer, el row este que
-->
está aquí, y yo intento
-->
mostrar los datos, o sea,
-->
para que me muestre los
-->
datos, va a tener un problema
-->
en el formato. ¿Por qué?
-->
Mirad a cuenta que el archivo
-->
me lo llevo todo de manera
-->
horizontal. Y lo que pasa es
-->
que hay un ARRAY de XML, o
-->
sea, de elementos de XML, hay
-->
un ARRAY. Entonces, ¿Qué
-->
pasa? Aquí me toca hacer lo
-->
siguiente, que es, en
-->
este caso, que tengo que
-->
leerlo desde el ROOT. O sea,
-->
tiene que coger este ROOT y
-->
cogerlo como el absolute
-->
PACK, o sea, ¿De dónde voy
-->
a empezar a leer los
-->
archivos? Y ahora, vas a
-->
coger todas estas columnas,
-->
le vas a dar, escoge la
-->
primera, presiona SHIFT, y
-->
vas hasta el final para
-->
seleccionar todo. Nuevamente,
-->
la primera, le das SHIFT
-->
aquí a EMAIL, y las sueltas
-->
de este lado. Y le das
-->
aquí un REFRESH, y de
-->
pronto te ha mostrado, y
-->
te muestra la medida para que
-->
veas la diferencia en que te
-->
va a mostrar los datos. Ya
-->
te muestro los datos en el
-->
formato establecido. ¿Qué
-->
pena que le haya explicado
-->
esto tan rápidamente, lo del
-->
XML PACK y lo del JSON
-->
PACK. Es que cuando hagas,
-->
por favor, dele aquí un
-->
REFRESH PREVIEW para que
-->
le muestre y usted pueda
-->
ver visualmente si los
-->
datos, en realidad, están
-->
en el formato adecuado.
-->
Vamos a darle aquí, entonces,
-->
NEXT. Te muestra cómo
-->
quedaría la metadata con
-->
los datos que él interpretó,
-->
a partir del PREVIEW, y le
-->
damos aquí FINISH.
-->
Entonces, vamos aquí en el
-->
mismo job, este que está
-->
aquí, por favor, se va a la
-->
metadata y expande ahora,
-->
suelta, escoge el archivo
-->
creado, selecciona, click
-->
sostenido, y lo suelta
-->
aquí en el canvas. Y le va
-->
a aparecer el más
-->
recomendable que es TEFA
-->
y el INPUT. ¿XML? OK.
-->
Pavel, en este caso, elimina
-->
el el el employee ID,
-->
selecciona ahí de DAS con
-->
SUPRIMIR. O si quieres, hazle
-->
lo siguiente, escoge ROW,
-->
mejor, escoge ROW, Pavel,
-->
escoge ROW, y lo sueltas en
-->
el solute PAP. Suéltalo en
-->
el solute PAP, para ese
-->
sobrescribe. Suéltalo ahí,
-->
ahí, suéltalo. Ahí, listo,
-->
y le das las columnas de
-->
employee, click ahí, shift, y
-->
le das click, ole, declash
-->
shift, baja con el clor,
-->
clíso sostenido ahí, shift
-->
sostenido, hasta el final,
-->
y le das click ahí, perfecto.
-->
Pasa todos a esos ahora a
-->
primero Haz ref介, a bueno,
-->
listo. Haz refresh, si
-->
refresh un momento, por
-->
favor, mientras, listo,
-->
perfecto, ahí lo tienes.
-->
Dale next, dale finish.
-->
Cambia, por favor, el donde
-->
estás ahora en code, cambia la
-->
design exactamente, y ahora
-->
suelta, ese señor lo
-->
suelta de este lado.
-->
Perfecto, lo sueltas ahí.
-->
y OK, agreguemos ahora un
-->
map por favor, un tmap, listo, a un tmap y agrega ahora no un telorode, sino voy a formatearlo a un
-->
archivo diferente de salida, voy a formatearlo a un json. Entonces si lo que vas es a una salida,
-->
ya cuando tú empiezas a acostumbrarte en la herramienta ya sabes cómo debería llamarse el
-->
componente sin necesidad de que lo sepas de memoria. Como lo que voy a crear es un archivo
-->
de salida entonces necesariamente tienes que empezar con tfile. Entonces tienes que empezar
-->
con tfile. Ahora, partiendo de que lo quiero, un archivo de salida json, entonces tiene que
-->
ser tfile json. Te pregunto ahora, es un archivo, como el archivo lo voy a escribir,
-->
tiene que ser de output, entonces escribe output aquí y te empiezas a colocar todo lo que
-->
empiezan por output. Ahora busca el formato en que lo quieras, que sería json, en pocas
-->
palabras, busca un componente, te voy a colocar aquí, que sea este nombre te lo voy
-->
a colocar aquí, sea tfile output porque es de salida, voy a escribirlo y aquí puede ser
-->
json, xml, etcétera, aquí sería json y escoge ese componente como tal. Procede a unir como
-->
hicimos en el joc anterior, en el bejebro anterior, perdón, conecta aquí el tmap y el
-->
tmap conectarlo aquí al tfile. Coloca lo siguiente ahora, si colocas salida donde
-->
formateada, por defecto los nombres tienen que ser únicos en el joc, entonces voy a cambiar el
-->
nombre de salida, underscore archivo, underscore json, pero recuerda que los nombres que coloque
-->
deben ser únicos en el joc, si intento colocar un nombre que ya exista me sale un error
-->
diciéndole de que no podía utilizar ese nombre. En realidad que el talent en la
-->
documentación que tiene no tiene buenas prácticas, o sea, perdón, no tiene un módulo
-->
que diga de buenas prácticas al nivel de nombrado. Tiene que basarse netamente en los
-->
estándares que haya definido a nivel de desarrollo. Ahora, tengo algunos documentos de algunos
-->
proyectos que han hecho de ciertas buenas prácticas de cómo están nombrándolos,
-->
que quizás podría compartirtelos y me escribes a mi correo, al final te digo mi correo y
-->
me escribes y te lo mando los documentos de algunas que yo he seguido y he tomado
-->
algunas cositas de acá, algunas cositas de allá y defino entonces un documento de buenas prácticas.
-->
Esto es perfecto. Solamente para practicar, bueno y aquí sería buena práctica en que
-->
esos nombres no sean genéricos row 1, row 2, entonces solamente lo voy a dar genérico por
-->
cuestión de tiempo, pero para practicar cómo hacemos para cambiarlo. Primero le das clic en
-->
el nombre y después le da otra vez clic y se estabilita para que puedas cambiarlo. Entonces
-->
aquí llámalo empleado. Ya te había dicho, cuando veas el punto rojo en algún componente indica
-->
o un error de configuración o falta de configuración, en este caso es falta de
-->
configuración con el tmap. Vamos aquí el tmap. Aquí te recomiendo lo siguiente,
-->
cuando vayas a mapear de aquí para acá, trata de ampliar un poco más esto que está
-->
aquí porque a veces se te colapsan todos en un mismo, todos los elementos de entradas
-->
te colapsan en un solo elemento. Entonces como buena práctica creo que aquí amplía acá
-->
y nada más lleva por favor tres columnas, las que tú quieras. En este caso voy a
-->
llevarme las tres primeras. Employee, voy a seleccionar con control y con clic. Employee,
-->
last name, first name y las voy a soltar de este lado nada más.
-->
Vamos aquí entonces. Y pasa lo siguiente, ¿para qué hizo esto de esta forma? Muy importante.
-->
En este caso tengo un job, pero note lo siguiente, tengo una división y estos
-->
colores me lo están indicando en que estos tres componentes que están aquí no están
-->
integrados con estos componentes de acá. ¿Qué es lo que está pasando internamente?
-->
Que en realidad ese job está dividido en dos subjobs. Si los componentes que tú tienes no están
-->
unidos, cada componente se ejecuta como un subjobs diferente. Si me decís, va ahí, va conmigo.
-->
Buena pregunta, que es lo que vamos a resolver ahora. Por defecto la herramienta no lo ejecuta
-->
en paralelo. La herramienta lo ejecuta, abro comillas doble, en la forma en que usted
-->
lo agregó. Partiendo del hecho en que yo agregué el primer subjob, este que está aquí,
-->
me ejecutaría este subjob primero y después me ejecutaría este subjob de acá.
-->
Aclaro que si vas a hacer esto con subjob, es mala práctica hacerlo de esta forma,
-->
porque una persona que lea el subjob no sabe en realidad cuál empieza,
-->
porque yo fácilmente pude haber colocado este señor de primero,
-->
pero en realidad no fue el primero que agregué. Entonces, pero bueno,
-->
así como está, está divido en dos subjobs. A nivel pragmático que viene siendo eso,
-->
como esto se ejecuta con Java, prácticamente muy rápidamente te lo voy a decir qué es lo
-->
que está pasando. En este caso, listo, aquí voy a crear aquí un diagram. A la pregunta,
-->
que creo que fue la que me hizo bueno, que está bien la pregunta y la resuelvo de esta forma,
-->
es si los subjobs no se ejecutan en paralelo, técnicamente lo que está pasando es lo
-->
siguiente. Tú tienes un procesador y el procesador está dividido por varios core,
-->
verdad? Cada core lo que hace es que ejecuta un hilo de un proceso en particular. El
-->
proceso velo como el job cuando lo ejecuto. Entonces, voy a colocar aquí este cuadro aquí,
-->
que no me salió tan buena la imagen aquí. Significa lo siguiente, que yo aquí tengo,
-->
por ejemplo, un core 1. Aquí tengo core 1, duplicar aquí, tengo el core 2. Recuerden que
-->
los procesadores hoy en día pues tiene varios core. Tengo un sola pastilla, tengo un procesador
-->
y ese procesador está compuesto por varios core. Y a nivel de servidores, tú puedes tener
-->
varios procesadores y cada procesador tiene un core diferente, duplicar aquí. Entonces,
-->
yo tengo un subjob 1, un subjob 1 y tengo un subjob 2. ¿Por qué tengo dos subjobs? Porque
-->
dos están unidos. Si están unidos, notará que él va solamente a reventar con un solo
-->
color muchas veces. Mire lo siguiente ahora. Si no se ejecutan en paralelo, significa
-->
entonces que cuando yo ejecute, va a tomar el core que esté ocioso, o sea que esté sin hacer
-->
nada. Primero ejecutaría el subjob 1, cuando termine el subjob 1, ejecutaría el subjob 2.
-->
O sea que los tiempos de respuesta ahí te van a demorar más tiempo. Eso depende porque muchas
-->
veces quisiera que se ejecutara uno primero y después el otro. Si se ejecutan en paralelo,
-->
entonces significa en que él va a intentar buscar, intentar porque muchas veces no lo
-->
va a intentar buscar o ejecutar este subjob en el core 1 y este subjob en el core 2. Y ahí se
-->
ejecutan de forma paralela, dando tiempos de respuesta mejores. Por defecto, por defecto,
-->
esto al final viene siendo Java lo que estoy mencionando, por defecto, por defecto la
-->
herramienta lo ejecuta primero uno y después ejecuta el otro. Es decir, no lo ejecuta en
-->
paralelo, por favor.
-->
Epa, fue muy rápido porque hay pocos registros y el formateo es. Entonces para que usted
-->
vea esto, haga lo siguiente, busque un componente que se llama T-sleep de sueño,
-->
slip slip de slip de slip que aparece como un relojito aquí para detener un
-->
poquito este yoke aquí de slip. Conecte el telo row
-->
con ese slip
-->
conecte el telo row con slip. Dele doble clic al slip para ver la
-->
configuración doble clic y te debe aparecer acá abajo la configuración
-->
aquí me está diciendo que por defecto estaba usando en segundos un segundo
-->
entonces vamos a ejecutar este yoke que está aquí
-->
note que ahora estoy ejecutando el primer yoke y todavía el segundo yoke
-->
no ha empezado a ejecutar debería entonces por la teoría de la herramienta
-->
cuando termine el de arriba seguir con el de abajo en términos pragmáticos
-->
cuando ejecuté está usando un treac un hilo de ejecución el treac va a
-->
intentar ejecutarlo sobre un solo cor
-->
efectivamente vea que lo ejecutó y terminó ahí entonces. Déjelo un segundo
-->
porque son 25 registros me está demorando 25 segundos ahí. Comprobado
-->
de forma secuencial y normalmente en el orden en que tú hayas agregado los
-->
subyokes. El caso de pavel tienes un error voy a ver qué error tienes
-->
a ver un momento y carga
-->
darle error
-->
vete a tu co un momento a tu co y sería bueno para ver aquí co para ver si
-->
hay un error. Nota que hay unos puntos rojos esos puntos rojos que hay un
-->
error de compilación en el yoke dale clic en alguno de los puntos rojos al
-->
parecer tienes un error en el vete al design en un momento
-->
nuevamente
-->
ahí está en realidad el error ahí está. Pavel mira lo siguiente lo que
-->
pasa es que hay n n columnas que están mapeando o sea tienes siete
-->
columnas que están mapeando una sola entonces hay un error de
-->
compilación ahí haz lo siguiente selecciona del lado derecho selecciona
-->
las dos filas esa fila listo que está aquí y ahora en la parte inferior del
-->
lado derecho vas a tener un más y un x entonces dale x
-->
listo ahora haz lo siguiente vete del lado derecho y amplía mejor la
-->
salida verticalmente para que sea verticalmente
-->
para que sea porque eso pasa porque es muy pequeño ahí cógelo ahí ahí sale
-->
cuando vas a la puntica y sale a veces listo perfecto ahora selecciona las
-->
columnas que quieras migrar pasa cuatro si tú quieres cuatro
-->
date cuenta que ahora estoy mapeando uno a uno y el bueno que estamos
-->
viendo de 7 a 1 dale ok ahora leyes y ahora sí vuelve a ejecutar para ver
-->
ahí entonces estamos ejecutando de forma secuencial para que pueda ejecutar el
-->
segundo tiempo que terminar entonces el subyoke del primero si tú deseas
-->
ejecutarlo de forma paralela te vas en la configuración del acá en la en la
-->
perspectiva de acá abajo te vas en la configuración del yo de la
-->
perspectiva entonces cuál sería sería la primera pestaña que tiene igual
-->
nombre del yo que dice trabajo yo transforme básica talidad clic aquí
-->
en la primera pestaña de la perspectiva de abajo
-->
aquí hay algo que dice extra y ve que tiene multitreat multitreate es a nivel
-->
de programación un triad y el triad va a intentar ejecutarse en un core si yo
-->
tengo dos trias significa que va a intentar buscar dos core para
-->
ejecutarse chulea por favor el multitreat
-->
y haz la ejecución nuevamente ahora con el cambio cuando cuando tú ejecutes el
-->
automáticamente y date cuenta que ahora te ejecuta de forma
-->
paralela esto ya tú tienes que entender que yo lo puedes hacer de otra
-->
forma que yo no lo haces si a buena pregunta lo que pasa es que quizás
-->
un subyoke dependa del otro por ejemplo quizás usted haga una
-->
transformación para generar un archivo y ese archivo lo necesita en
-->
segundo subyoke entonces no podría ejecutarlo multitreat porque quizás
-->
cuando lo ejecuta todavía el archivo no está listo al final depende como todo
-->
el sistema depende liso no sé si hacemos el pequeño break de 20
-->
minuticos y volvemos