Skip to content

Release Notes

Jump to bottom
Developer Code from HuemulSolutions edited this page May 19, 2021 · 21 revisions

Release 2.6.3

Este nuevo release contiene lo siguiente:

Implementa las siguientes mejoras:

  • issue #135: Máximo tiempo de espera en sigleton. Se crea método setMaxMinutesWaitInSingleton en globalSettings, el valor por default es 720 minutos
  • issue #136: Agregar máxima cantidad de reintentos para validar si app está viva. Se crea método setMaxAttemptApplicationInUse en globalSettings, con valor por default 5

Release 2.6.2

Este nuevo release contiene lo siguiente:

Implementa las siguientes mejoras:

  • issue #130: permite redirección de URL para monitoreo de singleton: al implementar algunas estrategias de seguridad, la api de monitoreo de la sesión es redireccionada. Esta mejora permite obtener la URL redireccionada
  • issue #131: agrega nuevo comportamiento para marcar registros eliminados en tablas master y reference: se agrega un nuevo método, para indicar si las filas que no existen en el origen, deben ser marcadas como eliminadas en el destino, o el status anterior se debe mantener #129 Bump junit from 4.11 to 4.13.1 --> recomendación de gitHub

Release 2.6.1

Este nuevo release contiene lo siguiente:

  • issue #119: Simplifica métodos DataLake: La definición de lectura desde la capa RAW (archivos TXT, CSV, ETC) se realiza de forma más simple. El siguiente ejemplo permite definir la lectura de un archivo txt de 6 columnas:
val dataLakeConfig: huemul_DataLakeSetting = new huemul_DataLakeSetting(huemulLib)
     .setStartDate(2010,1,1,0,0,0)
     .setEndDate(2050,12,12,0,0,0)
     //Path & names
     .setGlobalPath(huemulLib.GlobalSettings.RAW_BigFiles_Path)
     .setLocalPath("local_path/")
     .setFileName("fileName_{{YYYY}}{{MM}}{{DD}}.txt")
     .setFileType(huemulType_FileType.TEXT_FILE)
     .setContactName("user name")
     //Data
     .setColumnDelimiterType(huemulType_Separator.CHARACTER)
     .setColumnDelimiter("\\|")
     .addColumn("periodo", "periodo", StringType,"periodo de los datos")
     .addColumn("empresa", "empresa", StringType,"Nombre de la empresa")
     .addColumn("app", "app", StringType,"Canal utilizado")
     .addColumn("producto", "producto", StringType,"nombre producto")
     .addColumn("cantidad", "cantidad", IntegerType,"Cantidad")
     .addColumn("precio", "precio", IntegerType,"Precio")
     //Header
     .setLogNumRowsColumnName(null)
       .setHeaderColumnDelimiterType(huemulType_Separator.CHARACTER)
       .setHeaderColumnDelimiter("\\|")
       .setHeaderColumnsString("VACIO")
  • issue #111: JDBC Url does not support % character in the password: En las versiones anteriores, el usuario y password de conexión con el modelo de control se enviaba usando el connectionString. A partir de la versión 2.6.1 se permite enviar de forma separada el usuario y password, de esta forma se pueden utilizar caracteres especiales. Al definir la cadena de conexión utilizando la clase huemul_KeyValuePath se puede enviar el userName y password a la conexión al modelo de control.
   Global.CONTROL_Setting.append(new huemul_KeyValuePath("production",controlConnString)
     .setUserName(controlUserName)
     .setPassword(controlPassword)
   )

  • issue #99: Capturar los parámetros de spark en la ejecución de procesos: Desde la versión 2.6.1 el modelo de control almacena los parámetros de ejecución de spark en la tabla "control_processexecenv", asociando la ejecución del proceso con la tabla "control_processExec". A nivel de desarrollo no tiene cambios, sin embargo para que este cambio sea aplicado se debe ejecutar el script de actualización del modelo de control entregado al final de este release, el cual crea esta nueva tabla y actualiza la versión de compatibilidad del modelo de control a 2.6.1

  • issue #54: Capturar los parámetros de spark en la ejecución de procesos: Se actualizan algunas dependencias a versiones más recientes.

Actualización desde versión 2.6

Para actualizar a esta nueva versión, se deben realizar las siguientes acciones:

1. Actualizar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_upgrade_2.6_to_2.6.1.sql

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.6.1 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

Release 2.6

Este nuevo release contiene lo siguiente:

  • issue #98: Opción para agregar columnas particionadas en tablas master y reference: Desde esta versión es posible tener más de un campo particionado en tablas de tipo transaction, y se incorpora la opción para particionar tablas de tipo master.
  • issue #112: Customizar nombre de columnas de control en tablas: Desde esta versión es posible asignar nombres propios a los campos mdm_processnew, mdm_processChange, mdm_fhCreate, mdm_fhChange y mdm_hash.
  • issue #67: Integración con BigQuery: A partir de esta versión se pueden guardar tablas parquet directamente en Google Cloud Storage. La creación de las tablas en BigQuery aún es manual y se abordará en próximos release.
  • issue #100: setDQ con Warning: Actualmente varias de las rutinas automáticas de DataQuality de huemul solo permitía generar errores sobre los procesos, a partir de esta versión es posible indicar el nivel de notificación de estas reglas, similar a la creación de reglas customizadas de DataQuality.

Detalle issue #98: Opción para agregar columnas particionadas en tablas master y reference:

Se crea un nuevo método en la clase huemul_columns:

  • setPartitionColumn(position,dropBeforeInsert, oneValuePerProcess): Este método permite indicar a cada columna de la tabla si es o no parte de la partición, recibe los siguientes parámetros:
    • position: indica la posición de la partición, por ejemplo si tiene 2 columnas de partición, la primera (1) irá en la parte más alta del arbol, y así sucesivamente.
    • dropBeforeInsert: Solo aplica para tablas de tipo transaction. Indica si la partición específica se debe borrar antes de insertar los nuevos valores. En caso que ninguna partición de la tabla esté en true, los valores anteriores nunca serán borrados, esto se debe tener presente por los reprocesos históricos. En caso que se requiera una tabla que almacene toda la historia y nunca sea borrada, se recomienda dejar todas las particiones con este parámetro en false.
    • onValueperProcess: Solo aplica para tblas de tipo transaction. Indica si el proceso en particular debe validar que la columna contenga un único valor. Usar este parámetro en true para indicar que un proceso solo puede contener un valor, por ejemplo si el campo particionado es una fecha, y en el archivo solo puede llegar una fecha a la vez, se debe dejar este atributo en true.

Ejemplo

  val periodo: huemul_Columns = new huemul_Columns(DateType,true,"Periodo de los datos")
                            .setIsPK().setPartitionColumn(1,false, true)
  val empresa: huemul_Columns = new huemul_Columns(StringType,true,"Empresa que registra ventas")
    .setPartitionColumn(2,true, false)
  val app: huemul_Columns = new huemul_Columns(StringType,true,"app que registra ventas")
    .setPartitionColumn(3,false, false)
  val producto: huemul_Columns = new huemul_Columns(StringType,true,"producto de la venta")
  val cantidad: huemul_Columns = new huemul_Columns(IntegerType,true,"Cantidad de productos vendidos")

En este ejemplo, se define una tabla con 4 columnas, con 3 columnas particionadas, el ejemplo y comportamiento de cada una de ellas se explica a continuación:

Tenemos un archivo diario de ventas de productos por empresa con la siguiente estructura y datos de ejemplo: archivo 20170501_com01.txt periodo empresa app producto cantidad 20170501 com01 internet chocolate 10 20170501 com01 tienda dulce 2

archivo 20170501_com02.txt periodo empresa app producto cantidad 20170501 com02 internet alfajor 5 20170501 com02 tienda jugo 3

archivo 20170502_com03_4.txt periodo empresa app producto cantidad 20170502 com03 internet flan 8 20170502 com04 tienda platano 6

El objetivo es poder cargar en la tabla estos archivos de forma independiente, debido a que llegan en distintos momentos del día, y se requiere generar un proceso eficiente de carga y consulta.

Por tanto, en nuestra tabla de tipo transaction definiremos tres columnas particionadas

  • periodo: es la primera columna particionada, en este caso el objetivo es hacer eficiente los filtros de usuarios por fechas, nunca se borrará esta partición directamente (dropBeforeInsert=false), debido a que cada empresa cargará los datos en momentos distintos del día, y cada archivo solo puede contener un periodo a la vez (onValueperProcess=true, en caso de tener dos periodos es un error)
  • empresa: es la segunda columna particionada, el objetivo es permitir cargar los datos transaccionales de forma independiente, y en caso de existir reproceso, se debe eliminar el contenido anterior (dropBeforeInsert=true) y volver a cargar. En nuestro ejemplo, un archivo podría contener más de una empresa (onValueperProcess=false)
  • app: es la tercera columna particionada, el objetivo es solo de optimización de subconsultas, debido a que se tienen pocas aplicaciones, pero mucha transaccionalidad, se generan particiones por este criterio. Esta columna permite múltiples valores (onValueperProcess=false)

En el último campo particionado, es indistinto usar el atributo dropBeforeInsert=true, debido a que siempre se borrará la partición específica de los valores de "empresa".

Consideraciones:

  • dropBeforeInsert=true solo borra particiones de datos que contiene el archivo que se está cargando: supongamos que tenemos las siguientes particiones:

    • periodo=2017-05-01/empresa=com01/app=internet
    • periodo=2017-05-01/empresa=com01/app=tienda
    • periodo=2017-05-01/empresa=com02/app=internet
    • periodo=2017-05-01/empresa=com02/app=tienda
    • periodo=2017-05-02/empresa=com03/app=internet
    • periodo=2017-05-02/empresa=com04/app=tienda

    En el caso que tengamos un nuevo archivo archivo 20170502_com03_4.txt con los siguientes datos

archivo 20170502_com03_4_v2.txt periodo empresa app producto cantidad 20170502 com03 internet flan 8 20170502 com04 tienda platano 6 20170502 com02 tienda manzana 7

Las acciones sobre las particiones se explican a continuación:

 * periodo=2017-05-01/empresa=com01/app=internet   (sin impacto)
 * periodo=2017-05-01/empresa=com01/app=tienda     (sin impacto)       
 * periodo=2017-05-01/empresa=com02/app=internet   (sin impacto)
 * periodo=2017-05-01/empresa=com02/app=tienda     (sin impacto)
 * periodo=2017-05-02/empresa=com03/app=internet   (elimina antigua, crea nuevamente)
 * periodo=2017-05-02/empresa=com04/app=tienda     (elimina antigua, crea nuevamente)
 * periodo=2017-05-02/empresa=com02/app=tienda     (nueva partición)

Detalle issue #112: Customizar nombre de columnas de control en tablas:

Creación de nuevos métodos en huemul_table para incluir nombres customizados a los campos de trazabilidad de cambios.

  • setNameForMDM_fhChange(value: String): permite asignar el nombre al campo que registra la fecha y hora de cambio en algún dato a nivel de fila. Solo tiene efecto en tablas de tipo "master" y "reference"
  • setNameForMDM_fhNew(value: String): permite asignar el nombre al campo que registra la fecha y hora en que se agregó la fila en la tabla. Aplica a todos los tipos de tabla
  • setNameForMDM_ProcessNew(value: String): permite asignar el nombre al campo que registra el proceso que agregó la fila. Aplica para todos los tipos de tabla.
  • setNameForMDM_ProcessChange(value: String): permite asignar el nombre al campo que registra el proceso que hizo algún cambio en la fila. Solo tiene efecto en tablas de tipo "master" y "reference"
  • setNameForMDM_hash(value: String): permite asignar el nombre al campo que calcula el valor Hash de la fila. Aplica para todos los tipos de tabla.
  • setNameForMDM_StatusReg(value: String): permite asignar el nombre al campo que indica el status de la fila (agregada, modificada o eliminada). Solo tiene efecto en tablas de tipo "master" y "reference"

El siguiente ejemplo en scala muestra la forma de usar al definir una tabla

class tbl_cliente (HuemulLib: huemul_BigDataGovernance, Control: huemul_Control) extends huemul_Table(HuemulLib,Control) with Serializable {

... 

    this.setNameForMDM_fhChange("customNameDtChange")
    this.setNameForMDM_fhNew("customNameDtNew")
    this.setNameForMDM_ProcessNew("customNameProcessNew")
    this.setNameForMDM_ProcessChange("customNameProcessChange")
    this.setNameForMDM_hash("customNameHash")
    this.setNameForMDM_StatusReg("customNameStatus")

...

}

Detalle issue #100: setDQ con Warning, Warning.Exclude

En esta nueva versión se permite a las reglas configurara el nivel de notificación (Error, Warning y Warning-Exclude)

Los nuevos métodos de notificación en la clase huemul_Columns son:

  • setIsUnique_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de valor único de la columna.

  • setDQ_Nullable_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de valor nulo para la columna.

  • setDQ_MinLen_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de largo minino para la columna.

  • setDQ_MaxLen_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de largo máximo para la columna.

  • setDQ_MinDecimalValue_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de valor decimal mínimo para la columna.

  • setDQ_MaxnDecimalValue_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de valor decimal máximo para la columna.

  • setDQ_MinDateTimeValue_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de valor DateTime mínimo para la columna.

  • setDQ_MaxDateTimeValue_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de valor DateTime máximo para la columna.

  • setDQ_RegExpression_Notification(notification: huemulType_DQNotification): permite asignar el nivel de notificación para la regla de validación de expresión regular para la columna.

  • setDQ_Notification(value: huemulType_DQNotification): permite asignar el nivel notificación general para todas las reglas, el orden de asignación de la notificación es la siguiente, si la regla de calidad no tiene configurada ninguna notificación específica, por ejemplo, no está especificado para el largo mínimo el setDQ_MinLen_Notification(), se tomara como regla de notificación general. Los nuevos métodos de notificación en la clase huemul_Tables son:

  • setPkNotification(value: huemulType_DQNotification): permite asignar el nivel de notificacion para la regla de validacion clave primara (pk ) para las columnas columna declaradads como PK. El siguiente ejemplo en scala muestra la forma de usar al definir una tabla

class tbl_cliente (HuemulLib: huemul_BigDataGovernance, Control: huemul_Control) extends huemul_Table(HuemulLib,Control) with Serializable {
 ...

  //Ejemplo de uso de notificación a nivel de regla de calidad de clave unica de las columnas definidas
  this.setPK_externalCode("COD_ERROR_PK")
  this.setPkNotification(huemulType_DQNotification.WARNING_EXCLUDE)

  val nombre: huemul_Columns = new huemul_Columns (StringType, true, "Nombre corto del país")
    	.setDQ_RegExpression("^\\\"A.*$")
    	.setDQ_RegExpression_Notification(huemulType_DQNotification.WARNING_EXCLUDE)
...

  //Ejemplo de uso de notificación a nivel de regla de calidad especifica
  val iso2: huemul_Columns = new huemul_Columns (StringType, true, "Código iso 2 letras")
    	.setDQ_MinLen(2,"ERROR_LEN_MIN")
    	.setDQ_MinLen_Notification(huemulType_DQNotification.WARNING_EXCLUDE)
    	.setDQ_MaxLen(3,"ERROR_LEN_MAX")
    	.setDQ_MaxLen_Notification(huemulType_DQNotification.WARNING_EXCLUDE)
    	.setIsUnique("ERROR_UNIQUE_2")
    	.setIsUnique_Notification(huemulType_DQNotification.WARNING_EXCLUDE)

  //Ejemplo de uso de notificación a nivel de regla de calidad general, donde para la regla calidad MinLen se aplica la notificación específica, para el resto la general
  val iso3: huemul_Columns = new huemul_Columns (StringType, true, "Código ISO 3 letras")
    	.setDQ_MinLen(3,"ERROR_LEN_MIN")
    	.setDQ_MinLen_Notification(huemulType_DQNotification.ERROR)
    	.setDQ_MaxLen(3,"ERROR_LEN_MAX")
    	.setIsUnique("ERROR_UNIQUE_3")
    	.setDQ_Notification(huemulType_DQNotification.WARNING)
...
}

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.6 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

Release 2.5

Este nuevo release contiene lo siguiente:

  • issue #106: Leer archivos AVRO, PARQUET Y ORC e integrarlos a clase huemul_dataLake: Desde esta versión es posible utilizar archivos PARQUET, AVRO Y ORC como definición de RAW, de esta forma es posible incluir la trazabilidad de estos archivos cuando el DataLake ha sido formado a partir de estos formatos y no directamente desde los ficheros origen.
  • issue #107: Compatibilidad con AVRO al guardar los datos con Huemul: Desde esta versión es posible utilizar AVRO como tipo de almacenamiento en Huemul. Al igual que PARQUET, puede ser utilizado para guardar tablas de tipo master como de tipo transaction.
  • issue #109: Integración con Hive Warehouse Connector: Permite utilizar el HWC para crear la metadata de HIVE en ecosistemas Hortonworks versiones 3.0.0 y 3.1.14.

Detalle issue #109: Integración con Hive Warehouse Connector:

Para utilizar el HortonWorks Hive Connector, se debe realizar lo siguiente:

  1. Habilitar en globalSettings la opción de conexión usando HWC
   Global.externalBBDD_conf.Using_HWC.setActive(true)
  1. Incluir driver y configuración de conexión en ejecución de spark-submit, el siguiente ejemplo grafica la forma de invocación
spark-submit ... --jars /usr/hdp/current/hive_warehouse_connector/hive-warehouse-connector-assembly-1.0.0.3.0.1.0-XX.jar  ... --conf "spark.sql.hive.hiveserver2.jdbc.url=jdbc:hive2://ambiente.hortonworks.com:2181/;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2;user=xxx;password=yyy"

donde XX es la versión específica del ambiente.

Detalle issue #106: Leer archivos AVRO, PARQUET Y ORC e integrarlos a clase huemul_dataLake

Para utilizar estos formatos como input de datos, se debe configura lo siguiente el tipo de archivo, y luego utilizar el objeto "DataRawDF" para acceder a los datos leidos:

  • para AVRO:
FormatSetting.FileType = huemulType_FileType.AVRO_FILE
  • para PARQUET:
FormatSetting.FileType = huemulType_FileType.PARQUET_FILE
  • para ORC:
FormatSetting.FileType = huemulType_FileType.ORC_FILE
  • para DELTA LAKE de Databricks:
FormatSetting.FileType = huemulType_FileType.DELTA_FILE

Finalmente, se debe agregar la siguiente línea posterior a abrir el archivo RAW:

this.DF_from_RAW(this.DataRawDF, Alias)

El objeto DataRawDF contiene el DF abierto desde el archivo especificado.

Detalle issue #107: Compatibilidad con AVRO al guardar los datos con Huemul

Se deben tener las siguientes consideraciones al trabajar con AVRO:

  • Usando Databricks El driver usado por Databricks permite compatibilidad casi completa con los tipos de datos con AVRO.

En la definición de las tablas, evitar el uso de smallint (ShortType). En caso de existir este tipo de datos en la definición de un campo, huemul automáticamente lo convertirá a Int, de esta forma se evitan conflictos al utilizar la tabla con HIVE.

  • Usando otros ecosistemas Al utilizar ambientes con spark anterior a 2.4 se debe utilizar el siguiente driver
<!-- https://mvnrepository.com/artifact/com.databricks/spark-avro -->
<dependency>
    <groupId>com.databricks</groupId>
    <artifactId>spark-avro_2.11</artifactId>
    <version>4.0.0</version>
</dependency>

Como señala la documentación, los tipos de datos date y timestamp no son soportados, y se almacenan internamente como Long. Por este motivo, y para evitar conflictos con procesamiento de usuario, se ha determinado convertir los tipos de dato "date" y "timestamp" a "varchar", de esta forma se mantiene el formato. Para el caso del tipo de dato Decimal, se almacena en AVRO como decimal, pero en la tabla externa creada en HIVE se utiliza string, por tanto se debe tener la precaución de realizar la conversión explícita al hacer operaciones matemáticas, debido a que HIVE puede entregar datos aproximados.

En conclusión, si los datos a almacenar considera decimal, date y timestamp, se recomienda usar otro tipo de almacenamiento al usar ecosistemas distintos a Databricks.

Actualización desde versión 2.4

Para actualizar a esta nueva versión, se deben realizar las siguientes acciones:

1. Actualizar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_upgrade_2.4_to_2.5.sql

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.5 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

Release 2.4

Este nuevo release contiene lo siguiente:

  • issue #91: Upgrade versión JDBC HIVE: Por recomendación de alertas gitHub se hace upgrade de dependencia de hive a 2.3.4. Sin impacto para desarrolladores.
  • issue #92: Lectura de PDF: Se incluye opción de leer archivos PDF en la capa RAW y generar un DataFrame aplicando transformaciones al texto.
  • issue #93: Reparar enlaces del README.md: Se reparan enlaces que no estaban funcionando en documentación.
  • issue #96: Incorporar DELTA Databricks como nuevo formato: Se agrega soporte para incorporar DELTA a los formatos de almacenamiento permitidos por Huemul. Esto agrega 100% de compatibilidad con el ecosistema de Databricks.
  • issue #102: Mejora performance OldValueTrace: Implementa mejora en performance y uso de memoria para las tablas maestras y de referencia que tengan alguna columna con la opción "setMDM_EnableOldValue_FullTrace" encendida. No tiene impactos para los desarrolladores.

Detalle issue #92: Lectura de PDF

Un ejemplo completo y funcional se puede encontrar en template desde la versión 2.4, ver https://github.com/HuemulSolutions/BigDataGovernance_2.4_TemplateBase

Para ejecutar la lectura desde PDF, se deben agregar en la llamada de spark-submit los siguientes jars:

  • tika-parsers-1.23.jar
  • tika-xmp-1.23.jar
  • pdfbox-2.0.18.jar
  • fontbox-2.0.18.jar
  • jempbox-1.8.16.jar
  • poi-4.1.1.jar

Detalle issue #96: Incorporar DELTA Databricks como nuevo formato.

Para usar este tipo de almacenamiento, se debe indicar el tipo de almacenamiento en la tabla de la siguiente forma:

this.setStorageType(huemulType_StorageType.PARQUET)

Adicionalmente, si el entorno de ejecución es Databricks, se debe incluir la siguiente configuración en globalSettings:

Global.setBigDataProvider( huemulType_bigDataProvider.databricks)

Para la configuración del modelo de control, en el caso de usar Databricks sobre Azure, se recomienda usar Azure Vault en conjunto con las opciones Secrets de Databricks, para ello se sugiere usar el siguiente tutorial https://docs.microsoft.com/en-us/azure/azure-databricks/store-secrets-azure-key-vault

Finalmente, las modificaciones concretas a realizar en globalSettings para la utilización de claves administradas por Azure y Databricks son las siguientes:

  1. Agregar dependencias de dbUtils a POM de proyecto globalSettings:
<!-- https://mvnrepository.com/artifact/com.databricks/dbutils-api -->
	<dependency>
	    <groupId>com.databricks</groupId>
	    <artifactId>dbutils-api_2.11</artifactId>
	    <version>0.0.4</version>
	</dependency>
  1. Leer JDBC connectionString para modelo de control desde la secrets
val dbutils = com.databricks.dbutils_v1.DBUtilsHolder.dbutils
   val lControlConnectionString = dbutils.secrets.get(scope = "[secret-scope]", key = "[production-demo-setting-control-connection]")
   Global.CONTROL_Setting.append(new huemul_KeyValuePath("production",lControlConnectionString))

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.4 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

Release 2.3.1

Este release contiene lo siguiente:

Bug:

  • issue #89: executeOnlyInsert sin Autorización para ejecutar métodos sobrecargados: Se resuelve bug

Mejoras:

  • Generador de código de tablas se genera en forma similar a template.

Release 2.3

Este nuevo release contiene lo siguiente:

  • issue #87: Creación de tablas externas en HIVE: Se agrega nueva opción en globalSettings para indicar conector JDBC de HIVE para crear metadata. Esta funcionalidad permite realizar las siguientes acciones:
    • En caso de utilizar versiones Hortonworks 3.0.0 hasta 3.1.4, la metadata de spark está separada de Hive, por tanto las tablas creadas desde spark no son visibles en Hive.
    • En caso de usar HBase: spark no permite crear tablas externas usando el SerDe de HBase. Para usar esta nueva funcionalidad, se deben agregar las siguientes líneas al código de globalSettings:
   //Agregar variable con opciones de conexió JDBC para HIVE
   val HIVE_Setting = new ArrayBuffer[huemul_KeyValuePath]()
   HIVE_Setting.append(new huemul_KeyValuePath("production",getKeyFromFile(s"${localPath}prod-demo-setting-hive-connection.set")))
   HIVE_Setting.append(new huemul_KeyValuePath("experimental",getKeyFromFile(s"${localPath}prod-demo-setting-hive-connection.set")))

   //Para indicar el uso adicional de HIVE mediante JDBC para crear la metadata.
   Global.externalBBDD_conf.Using_HIVE.setActive(true).setActiveForHBASE(true).setConnectionStrings(HIVE_Setting)

Cuando se activa esta opción, también se mantiene activa la creación de metadata usando Spark.

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.3 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

Release 2.2

Este nuevo release contiene lo siguiente:

  • issue #79: Eliminar Backup de tablas maestras y de referencia: Agrega método control_getBackupToDelete(numBackupToMaintain: Int): Boolean. Recibe el parámetro "numBackupToMaintain" que indica la cantidad de backup que se mantendrán en HDFS (los "N" más nuevos). El resto los elimina.
  • issue #66: Integración con ORC: Se agrega soporte para almacenar tablas en formato ORC. El siguiente ejemplo permite almacenar una tabla en formato ORC:
class tbl_demo_ORC(huemulBigDataGov: huemul_BigDataGovernance, Control: huemul_Control) extends huemul_Table(huemulBigDataGov, Control) with Serializable {
  /**********   C O N F I G U R A C I O N   D E   L A   T A B L A   ****************************************/
  //Tipo de tabla, Master y Reference son catalogos sin particiones de periodo
  this.setTableType(huemulType_Tables.Master)
  //Tipo de archivo que sera almacenado en HDFS
  this.setStorageType(huemulType_StorageType.ORC)
  ...

  • issue #65: Integración con HBase: Se agrega soporte para almacenar tablas de referencia y maestras en HBase. Para guardar una tabla en HBase, se debe considerar lo siguiente:

    • Solo se permite tablas de tipo "reference" y "master"
    • Se debe especificar tipo de almacenamiento "HBase"

El siguiente ejemplo muestra la configuración para tabla de tipo HBase:

class tbl_demo_HBASE(huemulBigDataGov: huemul_BigDataGovernance, Control: huemul_Control) extends huemul_Table(huemulBigDataGov, Control) with Serializable {
  /**********   C O N F I G U R A C I O N   D E   L A   T A B L A   ****************************************/
  //Tipo de tabla, Master y Reference son catalogos sin particiones de periodo
  this.setTableType(huemulType_Tables.Master)
  //Tipo de archivo que sera almacenado en HDFS
  this.setStorageType(huemulType_StorageType.HBASE)
  ...

  //en definición de columna, se agrega método setHBaseCatalogMapping(nomFamilia, nomCampoHBase)
  val tu_columna = new huemul_Columns (StringType, true, "descripción de la columna", false).setHBaseCatalogMapping("nombre_familia","nombre_campo_en_hbase")

Debido a la naturaleza de HBase, se debe tener presente lo siguiente:

  • HBase admite únicamente un campo como PK, en caso que la tabla definida tenga dos o más campos de PK, huemul creará uno nuevo concatenando los campos definidos por el usuario (esto solo en caso de que la tabla de usuario tenga una PK compuesta).
  • HBase es eficiente para acceder a registros en particular, por tanto se sugiere que las tablas almacenadas como HBase sean pequeñas. En caso de crear tablas de mayor tamaño, o que el usuario realice muchas operaciones de agrupación, se recomienda otro tipo de almacenamiento (por ejemplo PARQUET u ORC).

En GlobalSettgins, se deben agregar las siguientes configuraciones:

  • HIVE_Setting: indicar JDBC para conectar directamente con HIVE, esto se utiliza para la creación de la tabla externa de HIVE hacia HBase (Spark no tiene soporte para crear una tabla externa de HBase en HIVE).
  • setHBase_available(): Habilita la conexión con HBase. Se debe invocar este método en GlobalSettings. Ejemplo:
Global.setHBase_available()
Global.HIVE_Setting.append(new huemul_KeyValuePath("production",getKeyFromFile(s"${localPath}prod-demo-setting-hive-connection.set")))
//Para indicar el uso adicional de HIVE mediante JDBC para crear la metadata (**actualizacion usando version 2.3**).
   Global.externalBBDD_conf.Using_HIVE.setActive(true).setActiveForHBASE(true).setConnectionStrings(HIVE_Setting)

Finalmente, para poder utilizar el almacenamiento de HBase desde Spark, se deben incluir las librerías necesarias para tales efectos, algunas recomendaciones son las siguientes:

  • Incluir hbase-site.xml en la ejecución: Incluir el siguiente parámetro
spark-submit --master yarn --files /etc/hbase/conf/hbase-site.xml
  • Incluir librerías JARS en la ejecución: Es caso que estos ficheros no estén en el classPath de ejecución de spark, se deben incluir en --JARS

A continuación se dan como ejemplo las rutas para la ejecución sobre un ambiente HortonWorks.

* /usr/hdp/current/hbase-client/lib/hbase-server.jar
* /usr/hdp/current/hbase-client/lib/hbase-spark.jar
* /usr/hdp/current/hbase-client/lib/hbase-common.jar
* /usr/hdp/current/hbase-client/lib/hbase-client.jar
* /usr/hdp/current/hbase-client/lib/hbase-protocol.jar
* /usr/hdp/current/hbase-client/lib/hbase-annotations.jar
* /usr/hdp/current/hbase-client/lib/hbase-hadoop-compat.jar
* /usr/hdp/current/hbase-client/lib/hbase-hadoop2-compat.jar
* /usr/hdp/current/hive-client/lib/hive-hbase-handler.jar
* /usr/hdp/current/hbase-client/lib/metrics-core-2.2.0.jar

Actualización desde versión 2.1

para actualizar a esta nueva versión, se deben realizar las siguientes acciones:

1. Actualizar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_upgrade_2.1_to_2.2.sql

2. Agregar configuración en globalSettings: Incluir la siguiente configuración opcional en el proyecto.

   //Agrega configuración para establecer conexión con HIVE usando JDBC, esto se utiliza para crear tablas externas de HIVE hacia HBase.
   Global.HIVE_Setting.append(new huemul_KeyValuePath("production",getKeyFromFile(s"${localPath}prod-demo-setting-hive-connection.set")))
   Global.HIVE_Setting.append(new huemul_KeyValuePath("experimental",getKeyFromFile(s"${localPath}prod-demo-setting-hive-connection.set")))
   Global.setHBase_available() //Habilita la conexión con HBase

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.2 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

A continuación se detallas los cambios de este release en cada clase.

Cambios en Clases / Funciones

Las siguientes clases y funciones tienen mejoras/cambios:

Clase huemul_Columns:

  • issue #65 El nuevo método setHBaseCatalogMapping(df: String, col: String = null): huemul_Columns, permite configurar la familia y nombre de campo en la tabla de HBase

Release 2.1

Este nuevo release contiene lo siguiente:

  • issue #56: Incorpora opción para dejar registros en detalle de DQ cuando se utiliza el método executeOnlyInsert
  • issue #58: Excluye registros que no cumplen con condiciones de DQ (con huemul_DataQuality y FK), para ello se agrega el tipo WARNING_EXCLUDE, quedando los tres tipos de notificación de la siguiente forma:
    • huemulType_DQNotification.WARNING_ERROR: Genera un error que detiene la ejecución.
    • huemulType_DQNotification.WARNING_EXCLUDE(nuevo): Genera un warning, excluye los registros que no cumplen con la condición (son almacenados en la tabla [nombre_tabla]_dq), y la ejecución continúa con el resto de las filas.
    • huemulType_DQNotification.WARNING: Se genera un warning, los registros con fallas son almacenados en la tabla detallada de DQ (en caso de estar activa) y la ejecución continúa con el 100% de las filas (buenas y malas).
  • issue #60: Incluye Id de DQ en la tabla de detalle de DQ: permite enlazar modelo de control con detalle de DQ
  • issue #62: Incorpora detalle del avance en las reglas de DQ, y posibilidad de separar la ejecución para ambientes pequeños.
  • issue #64: Crea método savePersistToDisk para guardar el resultado de un DF en HDFS
  • issue #68: Permite crear cache de metadata de HIVE para mejorar tiempo de respuesta al inicio de ejecución.
  • issue #71: Incorpora versión del modelo de control para mejorar la compatibilidad entre versiones.
  • issue #72: Guarda la versión de huemul y modelo de control ejecutados en la tabla control_processExec
  • issue #73: Parametrizar los códigos de error externos para PK y FK
  • issue #63: Optimización de código:

Actualización desde versión 2.0 y 2.0.1

Para actualizar a esta nueva versión, se deben realizar las siguientes acciones:

1. Actualizar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_upgrade_2.0_to_2.1.sql

2. Agregar configuración en globalSettings: Incluir la siguiente configuración opcional en el proyecto.

   Global.HIVE_HourToUpdateMetadata = 5 //indica la cantidad de horas para refrescar el cache de metadata obtenido desde HIVE

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.1 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

A continuación se detallas los cambios de este release en cada clase.

Cambios en Clases / Funciones

Las siguientes clases y funciones tienen mejoras/cambios:

Clase huemul_DataFrame:

  • issue #64 El nuevo método savePersistToDisk permite guardar los resultados de un DF en formato parquet, recibe los siguientes parámetros:
    • OverriteIfExist: Boolean: Indica si debe sobreescribir el contenido anterior de la tabla (true), de lo contrario (false), agrega el nuevo contenido al ya existente.
    • tableNameInHive: String: Indica el nombre que tendrá la tabla en Hive. El mismo nombre es utilizado para crear la estructura parquet.
    • localPath: String: Indica la ruta local donde se guardarán los datos, esto a partir de la ruta global.
    • globalPath: ArrayBuffer[huemul_KeyValuePath]: ruta global donde se guardará el fichero parquet (ruta definida en globalSettings). Este parámetro es opcional, en caso de no especificar se toma la ruta definida en SANDBOX_BigFiles_Path.
    • databaseName: ArrayBuffer[huemul_KeyValuePath: Este parámetro es opcional e indica la base de datos donde se creará la tabla en hive. En caso de no especificar, la tabla será creada en la base de datos Sandbox (SANDBOX_DataBase).

Ejemplo: el siguiente ejemplo muestra la apertura de un archivo RAW de taxis de NewYork, el dataFrame resultante es guardado en disco con el nombre "taxi_yellow_${param_year}_${param_month}"

      var DF_RAW =  new yellow_tripdata_mes(huemulBigDataGov, Control)
      if (!DF_RAW.open("DF_RAW", Control, param_year, param_month, 1, 0, 0, 0))       
        Control.RaiseError(s"error encontrado, abortar: ${DF_RAW.Error.ControlError_Message}")
      
      Control.NewStep("Guardando datos en bruto en sandbox")
      DF_RAW.DataFramehuemul.savePersistToDisk(true, s"taxi_yellow_${param_year}_${param_month}", "taxi") //, globalPath, databaseName)

Clase huemul_Table:

  • issue #73 implementa el método setPK_externalCode(value: String): Indica el código externo para indicar la validación de PK sobre la tabla.

  • issue #56 El método executeOnlyInsert de huemul_table tiene tres variantes

def executeOnlyInsert(NewAlias: String, storageLevelOfDF: org.apache.spark.storage.StorageLevel = null): Boolean --> compatible con versiones anteriores

def executeOnlyInsert(NewAlias: String, RegisterOnlyInsertInDQ: Boolean): Boolean --> nueva variante, requiere el parámetro RegisterOnlyInsertInDQ

def executeOnlyInsert(NewAlias: String, storageLevelOfDF: org.apache.spark.storage.StorageLevel, RegisterOnlyInsertInDQ: Boolean): Boolean --> nueva variante, requiere los parámetros storageLevelOfDF (antiguo) y RegisterOnlyInsertInDQ (nuevo parámetro).

El valor por default para el nuevo parámetro RegisterOnlyInsertInDQ es false, de esta forma se mantiene compatibilidad con versiones anteriores.

  • issue #58 Se agrega el método setSaveDQErrorOnce(value: Boolean), el valor true indica que guardará el resultado de DQ de una sola vez, acumulando todos los resultados en un DF, mientras que el valor false indica que guardará el detalle de DQ cada vez que lo detecta. El valor false permite usar menos memoria en el ambiente, sin embargo graba mas veces en disco. El valor por default es true.

Clase huemul_Table_Relationship:

  • issue #73 implementa los siguientes métodos:
  • setExternalCode(value: String): huemul_Table_Relationship: Indica el código externo para indicar la validación de FK.

Ejemplo:

  val itbl_DatosBasicos = new tbl_DatosBasicos(HuemulLib,Control)
  val fk_tbl_DatosBasicos = new huemul_Table_Relationship(itbl_DatosBasicos, false).setExternalCode("USER_FK_CODE")
  fk_tbl_DatosBasicos.AddRelationship(itbl_DatosBasicos.TipoValor , TipoValor)
  • issue #58 Se agrega el método setNotification(value: huemulType_DQNotification), el cual indica el nivel de criticidad de la validación de FK

Ejemplo en FK:

  val itbl_DatosBasicos = new tbl_DatosBasicos(HuemulLib,Control)
  val fk_tbl_DatosBasicos = new huemul_Table_Relationship(itbl_DatosBasicos, false).setNotification(huemulType_DQNotification.WARNING_EXCLUDE).broadcastJoin(true)
  fk_tbl_DatosBasicos.AddRelationship(itbl_DatosBasicos.TipoValor , TipoValor)

El valor por default es "ERROR", de esta forma se mantiene el comportamiento y compatibilidad con versiones anteriores. las opciones ahora son las siguientes:

  • huemulType_DQNotification.WARNING_ERROR: Genera un error que detiene la ejecución.
  • huemulType_DQNotification.WARNING_EXCLUDE: Genera un warning, excluye los registros que no cumplen con la condición (son almacenados en la tabla [nombre_tabla]_dq), y la ejecución continúa con el resto de las filas.
  • huemulType_DQNotification.WARNING: Se genera un warning, los registros con fallas son almacenados en la tabla detallada de DQ (en caso de estar activa) y la ejecución continúa con el 100% de las filas (buenas y malas).

Clase huemul_Columns:

  • issue #73 implementa los siguientes métodos:

  • setIsUnique(externalCode: String = null): huemul_Columns: Indica que campo es parte de la PK, y en parámetro indica código externo. Este método reemplazará al método setIsUnique(value: Boolean), el cual será deprecado en la versión 3.0

  • setNullable(externalCode: String = null): huemul_Columns: Indica que campo permite nulos, y en parámetro indica código externo. Este método reemplazará al método setNullable(value: Boolean), el cual será deprecado en la versión 3.0

  • setDQ_MinLen(value: Integer, externalCode: String = null): huemul_Columns: Indica el largo mínimo del campo, en el segundo parámetro indica código externo. Este método reemplazará al método setDQ_MinLen(value: Integer), el cual será deprecado en la versión 3.0

  • setDQ_MaxLen(value: Integer, externalCode: String = null): huemul_Columns: Indica el largo máximo del campo, en el segundo parámetro indica código externo. Este método reemplazará al método setDQ_MaxLen(value: Integer), el cual será deprecado en la versión 3.0

  • setDQ_MinDecimalValue(value: Decimal, externalCode: String = null): huemul_Columns: Indica el valor decimal mínimo para el campo, en el segundo parámetro indica código externo. Este método reemplazará al método setDQ_MinDecimalValue(value: Decimal), el cual será deprecado en la versión 3.0

  • setDQ_MaxDecimalValue(value: Decimal, externalCode: String = null): huemul_Columns: Indica el valor decimal máximo para el campo, en el segundo parámetro indica código externo. Este método reemplazará al método setDQ_MaxDecimalValue(value: Decimal), el cual será deprecado en la versión 3.0

  • setDQ_MinDateTimeValue(value: String, externalCode: String = null): huemul_Columns: Indica el valor mínimo de fecha y hora aceptado, en el segundo parámetro indica código externo. Este método reemplazará al método setDQ_MinDateTimeValue(value: String), el cual será deprecado en la versión 3.0

  • setDQ_MaxDateTimeValue(value: String, externalCode: String = null): huemul_Columns: Indica el valor máximo de fecha y hora aceptado, en el segundo parámetro indica código externo. Este método reemplazará al método setDQ_MaxDateTimeValue(value: String), el cual será deprecado en la versión 3.0

Release 2.0

Este nuevo release contiene lo siguiente:

Resumen nuevas funcionalidades:

  • issue #16: Permite indicar opción de hacer backup sobre tablas maestras y de referencia. Para ello en globalSettings se debe agrega el atributo MDM_SaveBackup para habilitarlo a nivel de aplicativo, MDM_Backup_Path para indicar el path y el método setSaveBackup en huemul_Tables para indicar qué tablas específicas se deben respaldar.
  • issue #34: En huemul_BigDataGovernance se agrega método huemul_showDemoLines para habilitar o deshabilitar el despliegue de 2 líneas de ejemplo al abrir un archivo RAW
  • issue #35: A partir de esta versión se incluye compatibilidad con Oracle y SQL Server para el modelo de control de procesos. Lo anterior se suma a compatibilidad con PostgreSQL y MySQL. Esta compatibilidad incluye aplicar cambios en los nombres de algunos campos en el modelo de control actual, todo esto se hace de forma automática ejecutando el script de actualización del modelo de control, por tanto todos los datos del modelo de control anterior se mantienen intactos.
  • issue #36: A partir de esta versión se almacena el resultante de DataQuality al fallar las reglas de Primary Key y Foreing Key.
  • issue #37: A partir de esta versión se incluye compatibilidad con log4j, de esta forma huemul registra toda su actividad utilizando esta librería.
  • issue #38: A partir de esta versión es posible incluir full trazabilidad de cambios en los valores de los campos para aquellas tablas que sean de tipo master y reference
  • issue #43: En huemul_DataQuality se agrega el método setDQ_ExternalCode que permite incluir un ID externo para enlazar las reglas de calidad con una herramienta de gestión externa.
  • issue #44: A partir de esta versión, se incorpora el linaje de datos a nivel de campos, esto es posible utilizando los métodos de transformación de DataFrame expuestos por Huemul a través de huemul_Tables, huemul_DataLake y huemul_DataFrame.
  • issue #45: En huemul_BigDataGovernance se agrega método hdfsPath_exists que retorna true si la ruta indicada existe en el directorio HDFS
  • issue #45: En huemul_BigDataGovernance se agrega método hiveTable_exists que retorna true si la base de datos y tabla existe en Hive
  • issue #45: En huemul_Table se agrega método getEmptyTable que retorna un DataFrame vacío con la estructura definida en la tabla, y crea una vista temporal con el nombre indicado en Alias
  • issue #48: En modelo de control de DataQuality ahora se registra la duración de aplicar la regla, y se determina si la regla generó como resultado un warning o un error.
  • issue #49: En huemul_Control agrega método getDQResult(), el cual retorna el resultante de la ejecución de Data Quality en un arreglo de datos, con la estructura del modelo de control
  • issue #49: En huemul_BigDataGovernance agrega método getPath(), el cual retorna el path indicado para una configuración específica.
  • issue #50: En huemul_control se agrega método para indicar un código externo de Glosario de Negocio.

Resumen cambios de comportamiento:

  • Ajustes al generador de código: Se adapta para incorporar los cambios de este release
  • issue #44: El método DF_from_DF recibe un nuevo parámetro "AliasFrom: String", ahora queda de la siguiente forma: DF_from_DF(DFFrom: DataFrame, AliasFrom: String, AliasTo: String).
  • issue #48: El atributo isError tendrá el valor true solo cuando algunas de las reglas haya fallado, y la clasificación de esa regla sea "ERROR", en caso que la clasificación sea "WARNING" no contendrá valor. El comportamiento anterior no discriminaba si era "ERROR" o "WARNING".
  • issue #35: Se debe ejecutar script de actualización del modelo de control por compatibilidad del modelo de control de procesos con Oracle.
  • Se cambia de mayúscula a minúscula algunos nombres de métodos y atributos.

Actualización desde versión 1.4.1

Para actualizar a esta nueva versión, se deben realizar las siguientes acciones:

1. Actualizar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_upgrade_1.4_to_2.0.sql

2. Agregar configuración en globalSettings: Incluir la siguiente configuración adicional en el proyecto (reemplazar valores de "database" y "path" según corresponda.

   //BACKUP
   Global.MDM_SaveBackup = true
   Global.MDM_Backup_Path.append(new huemul_KeyValuePath("production","hdfs:///user/data/production/backup/"))
   Global.MDM_Backup_Path.append(new huemul_KeyValuePath("experimental","hdfs://hdfs:///user/data/experimental/backup/"))
      
   //DATA QUALITY PATH & DATABASE
   Global.DQ_SaveErrorDetails = true
   Global.DQError_DataBase.append(new huemul_KeyValuePath("production","production_master"))   
   Global.DQError_DataBase.append(new huemul_KeyValuePath("experimental","experimental_master"))
   
   Global.DQError_Path.append(new huemul_KeyValuePath("production","hdfs:///user/data/production/dq/"))
   Global.DQError_Path.append(new huemul_KeyValuePath("experimental","hdfs://hdfs:///user/data/experimental/dq/"))
   
   //MDM OLD VALUE FULL TRACE PATH & DATABASE
   Global.MDM_SaveOldValueTrace = true
   Global.MDM_OldValueTrace_DataBase.append(new huemul_KeyValuePath("production","production_oldvalue"))   
   Global.MDM_OldValueTrace_DataBase.append(new huemul_KeyValuePath("experimental","experimental_oldvalue"))
   
   Global.MDM_OldValueTrace_Path.append(new huemul_KeyValuePath("production","hdfs:///user/data/production/oldvalue/"))
   Global.MDM_OldValueTrace_Path.append(new huemul_KeyValuePath("experimental","hdfs://hdfs:///user/data/experimental/oldvalue/"))

3. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

Nueva Instalación

Para una instalación nueva, se deben realizar las siguientes acciones:

1. Instalar modelo de control de procesos: para ello ejecutar el siguiente script huemul_bdg_2.0 SQL

2. Incluir huemul_sql_decode.jar en la ejecución de spark-submit: Se requiere este JAR adicional para la generación del linaje a nivel de campos y track de querys. Descargar desde mvn repository

A continuación se detallas los cambios de este release en cada clase.

Cambios en Clases / Funciones

Las siguientes clases y funciones tienen mejoras/cambios:

Clase huemul_BigDataGovernance:

  • issue #34 huemul_showDemoLines(value: Boolean): Habilitar o deshabilitar el despliegue de 2 líneas de ejemplo al abrir un archivo RAW. Por default contiene el valor "true", de tal forma de mantener el comportamiento con versiones anteriores.
  //En este ejemplo, se deshabilita la muestra de 2 líneas de ejemplo al leer cualquier archivo RAW
  huemul_showDemoLines(false)
  • issue #45 hdfsPath_exists(path: String): Boolean. Retorna true si la ruta indicada existe en el directorio HDFS
  if (huemulLib.hdfsPath_exists("hdfs:///user/data/production/temp/")
   println("existe")
  • issue #45 hiveTable_exists(database_name: String, table_name: String): Boolean. Retorna true si la base de datos y tabla existe en Hive
  if (huemulLib.hiveTable_exists("production_master", "tbl_DatosBasicos_mes"))
      println("tabla existe")
  • issue #49 getPath(pathFromGlobal: ArrayBuffer[huemul_KeyValuePath]): String: Retorna el path específico según el esquema entregado.
  //Retorna el path donde se almacenan los backup de tablas maestras
  val ruta = getPath(GlobalSettings.MDM_Backup_Path)

Clase huemul_Tables:

  • issue #16 setSaveBackup(value: Boolean): Permite respaldar el contenido de la tabla. Este backup se ejecuta cada vez que se producen cambios en la tabla, y guarda la versión anterior (es decir, antes de ser procesada). Por default esta opción está deshabilitada, por tanto se debe indicar en forma explícita..
  class tbl_DatosBasicos(HuemulLib: huemul_BigDataGovernance, Control: huemul_Control) extends huemul_Table(HuemulLib,Control) with Serializable {
  ...
  this.setSaveBackup(true)
   ...

  this.ApplyTableDefinition()
}
  • issue #44 DF_from_RAW(dataLake_RAW: huemul_DataLake, AliasTo: String). Permite asignar un DataFrame externo al objeto huemul_Table, y registrar el linaje de datos a nivel de cada campo.
  val DF_RAW_final =  new raw_DatosOldValue(huemulLib, Control)      
if (!DF_RAW_final.open("DF_RAW_final", Control, Ano.toInt, Mes.toInt, 1, 0, 0, 0,"fin")) {
  Control.RaiseError(s"Error al intentar abrir archivo de datos fin: ${DF_RAW.Error.ControlError_Message}")
}

TablaMaster.DF_from_RAW(DF_RAW, "DF_Original")
  • issue #44 DF_from_DF(DFFrom: DataFrame, AliasFrom: String, AliasTo: String). Modificación vs versiones anteriores. Permite asignar un DataFrame externo al objeto huemul_Table. En esta versión, se agrega el parámetro "AliasFrom: String", el cual enlaza el Alias de SQL anterior con el nuevo Alias SQL, de esta forma se crea el linaje de datos.
  val DF_RAW_final =  new raw_DatosOldValue(huemulLib, Control)      
if (!DF_RAW_final.open("DF_RAW_final", Control, Ano.toInt, Mes.toInt, 1, 0, 0, 0,"fin")) {
  Control.RaiseError(s"Error al intentar abrir archivo de datos fin: ${DF_RAW.Error.ControlError_Message}")
}

TablaMaster.DF_from_DF(DF_RAW.DataFramehuemul.DataFrame, "DF_RAW_final", "DF_Original")
  • issue #45 getEmptyTable(Alias: String): DataFrame. Retorna un DataFrame vacío con la estructura definida en la tabla, y crea una vista temporal con el nombre indicado en Alias
  val TablaMaster = new tbl_DatosBasicos(huemulLib, 
  val df_temp_vacia = TablaMaster.getEmptyTable("pruebaVacia")
  df_temp_vacia.show()

Clase huemul_Columns:

  • issue #38 setMDM_EnableOldValue_FullTrace(value: Boolean): Indica que se guardará la historia de todos los cambios sufridos por un campo en particular.
  val Monto = new huemul_Columns(IntegerType,true,"datos Monto")
  Monto.setMDM_EnableOldValue_FullTrace( true)
  • issue #50 setBusinessGlossary_Id(value: String): permite registrar un código del concepto de negocio asociado al campo. .
  val cliente_nombre = new huemul_Columns(StringType,true,"primer nombre del cliente")
  cliente_nombre.setBusinessGlossary_Id("BG_0015")

Clase huemul_Control:

  • issue #49 getDQResult(): Retorna el resultante de la ejecución de Data Quality en un arreglo de datos, con la estructura del modelo de control.
  val Resultado = Control.getDQResult()

Clase huemul_DataQuality: Se agrega opción de incluir un ID externo de regla de Calidad de Datos, se puede hacer de dos formas, las cuales son abordadas por el issue #43.

  • issue #43 Constructor: Se agrega nuevo parámetro al final del constructor, que permite incluir un Id Externo que identifique una regla de DQ específica
  val DQ_Regla = new huemul_DataQuality(CampoDeTabla,"Valida completitud del campo","CampoDeTabla in (1,2,3,4,5)",1,huemulType_DQQueryLevel.row, huemulType_DQNotification.WARNING, true, **"EC_002"** )
  • issue #43 setDQ_ExternalCode(value: String): incluir un Id Externo que identifique una regla de DQ específica
  val Resultado = Control.getDQResult()

Clase huemul_DataQualityResult:

  • issue #48 isWarning: Boolean: Nuevo atributo el cual indica si el resultado de todas las reglas de DQ aplicadas obtuvo warnings. El atributo isError tendrá el valor true solo cuando algunas de las reglas haya fallado, y la clasificación de esa regla sea "ERROR"

Clase huemul_DQRecord:

  • issue #48 DQ_IsWarning: Boolean: Indica true cuando el resultado de la regla no es el esperado, y la regla en cuestión fue declarada como tipo Warning
  • issue #48 DQ_duration_hour: Integer: retorna la cantidad de horas que se demoró en ejecutar la regla
  • issue #48 DQ_duration_minute: Integer: retorna la cantidad de minutos que se demoró en ejecutar la regla
  • issue #48 DQ_duration_second: Integer: retorna la cantidad de segundos que se demoró en ejecutar la regla
  • issue #48 Codificación de DataQuality: Se incorpora la siguiente codificación al ejecutar las reglas de DQ predefinidas por huemul:
    • HUEMUL_DQ_001: foreing key
    • HUEMUL_DQ_002: primary key
    • HUEMUL_DQ_003: unique column
    • HUEMUL_DQ_004: not null column
    • HUEMUL_DQ_005: reg_exp validation for Column
    • HUEMUL_DQ_006: string length DQ for Column
    • HUEMUL_DQ_007: number range
    • HUEMUL_DQ_008: DateTime range

Clase globalSettings:

  • issue #16 MDM_Backup_Path(value: Boolean): Por default está habilitada la opción de guardar backup, por ello se debe incluir el path donde se almacenarán los archivos de backup.
  //En este ejemplo, se habilita la opción de guardar y se identifica el path
  Global.MDM_SaveBackup = false
  Global.MDM_Backup_Path.append(new huemul_KeyValuePath("production","hdfs:///user/data/production/backup/"))
  • issue #38 MDM_SaveOldValueTrace (value: Boolean): Habilita la trazabilidad de cambios en los valores de los campos para tablas de tipo master y reference. Adicionalmente, se crean los métodos MDM_OldValueTrace_DataBase y MDM_OldValueTrace_Path para especificar la base de datos en hive y path (respectivamente) donde se guardarán las estructuras de datos con la información histórica
  //En este ejemplo, se habilita la opción de guardar y se identifica el path
  Global.MDM_SaveOldValueTrace = true

  Global.MDM_OldValueTrace_DataBase.append(new huemul_KeyValuePath("production","production_mdm_oldvalue"))
  Global.MDM_OldValueTrace_DataBase.append(new huemul_KeyValuePath("experimental","experimental_mdm_oldvalue"))

  Global.MDM_OldValueTrace_Path.append(new huemul_KeyValuePath("production","hdfs:///user/data/production/mdm_oldvalue/"))
  Global.MDM_OldValueTrace_Path.append(new huemul_KeyValuePath("experimental","hdfs:///user/data/experimental/mdm_oldvalue/"))

Corrección de Bug

Se implementan las siguientes correcciones:

  • En modelo de control se duplica registro al intentar registrar dos veces el uso de una tabla en proceso. Se corrige cambiando la PK de tabla control_tablesuse.

Release 1.4

A continuación se detallas los cambios de este release.

Nuevo comportamiento en la versión 1.4

No hay nuevos comportamientos en esta versión

Cambios en Clases / Funciones

Las siguientes clases y funciones tienen mejoras:

Clase huemul_Control:

  • TestPlan_CurrentIsOK(TotalOkExpected: Integer = null): Boolean (issue #33) Determina si todos los casos de prueba de la clase donde se ejecuta el modelo de control termina según lo esperado .
//Espera que se hayan ejecutado 10 casos de prueba en forma correcta, si el parámetro no se especifica, se espera que el 100% de los casos ejecutados hayan terminado de forma correcta
if (!control.TestPlan_CurrentIsOK(10)) {
  //error
}
  • TestPlan_IsOkById(TestPlanId: String, TotalProcessExpected: Integer ): Boolean (issue #33) verifica que "TotalProcessExpected" cantidad de clases hayan terminado correctamente el plan de pruebas, para ello se debe haber validado la ejecución del plan de pruebas de cada clase con el método TestPlan_CurrentIsOK .
//Espera que se hayan ejecutado 5 clases correctamente 
if (!control.TestPlan_IsOkById("testplan_001",5)) {
  //error
}

Corrección de Bug

Se implementan las siguientes correcciones:

  • Corrección de bug al almacenar detalle de filas con error en DQ.

Release 1.3.1

A continuación se detallas los cambios de este release.

Nuevo comportamiento en la versión 1.3

No hay nuevos comportamientos en esta versión

Cambios en Clases / Funciones

Las siguientes clases y funciones tienen las siguientes mejoras:

Clase huemul_BigDataGovernance:

  • huemul_BigDataGovernance (appName: String, args: Array[String], globalSettings: huemul_GlobalPath, LocalSparkSession: SparkSession = null): Se agrega parámetro LocalSparkSession, lo cual permite al desarrollador enviar su propia sesión de spark. Esto permite mayor nivel de parametrización de Spark.

Clase huemul_Table:

  • setNumPartitions: (issue #24) Indica el número de particiones que se almacena al escribir un archivo. El valor predeterminado es null, por tanto se determina en forma automática por Spark. En tablas pequeñas se recomienda que el número de particiones sea bajo (por ejemplo 2), de esta forma se evita el problema de los archivos pequeños de spark.
//Indica el número de particiones
setNumPartitions(2)

  • DF_from_SQL(Alias: String, sql: String, SaveInTemp: Boolean = true, NumPartitions: Integer = null): (issue #24) Se agrega parámetro NumPartitions para señalar la cantidad de particiones que utilizará spark para almacenar el resultado temporal del DataFrame.

  • executeFull(NewAlias: String, storageLevelOfDF: org.apache.spark.storage.StorageLevel = null): Agrega parámetro storageLevelOfDF. Esta mejora permite al desarrollador enviar el resultado del DataFrame final a memoria (por ejemplo usando MEMORY_ONLY), por tanto la ejecución de los procesos de DataQuality y validación de integridad referencia se reducen en forma importante. Esto es equivalente a usar el método DataFrame.persist(StorageLevel)

//Ejemplo de uso
TablaMaster.executeFull("DF_Final", org.apache.spark.storage.StorageLevel.MEMORY_ONLY )
  • executeOnlyInsert(NewAlias: String, storageLevelOfDF: org.apache.spark.storage.StorageLevel = null): Agrega parámetro storageLevelOfDF. Esta mejora permite al desarrollador enviar el resultado del DataFrame final a memoria (por ejemplo usando MEMORY_ONLY), por tanto la ejecución de los procesos de DataQuality y validación de integridad referencia se reducen en forma importante. Esto es equivalente a usar el método DataFrame.persist(StorageLevel) 
//Ejemplo de uso
TablaMaster.executeOnlyInsert("DF_Final", org.apache.spark.storage.StorageLevel.MEMORY_ONLY )
  • executeOnlyUpdate(NewAlias: String, storageLevelOfDF: org.apache.spark.storage.StorageLevel = null): Agrega parámetro storageLevelOfDF. Esta mejora permite al desarrollador enviar el resultado del DataFrame final a memoria (por ejemplo usando MEMORY_ONLY), por tanto la ejecución de los procesos de DataQuality y validación de integridad referencia se reducen en forma importante. Esto es equivalente a usar el método DataFrame.persist(StorageLevel) 
//Ejemplo de uso
TablaMaster.executeOnlyUpdate("DF_Final", org.apache.spark.storage.StorageLevel.MEMORY_ONLY )
  • executeSelectiveUpdate(NewAlias: String, PartitionValueForSelectiveUpdate: String, storageLevelOfDF: org.apache.spark.storage.StorageLevel = null): Agrega parámetro storageLevelOfDF. Esta mejora permite al desarrollador enviar el resultado del DataFrame final a memoria (por ejemplo usando MEMORY_ONLY), por tanto la ejecución de los procesos de DataQuality y validación de integridad referencia se reducen en forma importante. Esto es equivalente a usar el método DataFrame.persist(StorageLevel) 
//Ejemplo de uso
TablaMaster.executeSelectiveUpdate("DF_Final", "2019-05-01", org.apache.spark.storage.StorageLevel.MEMORY_ONLY )

Clase huemul_DataFrame:

  • DF_from_SQL(Alias: String, sql: String, SaveInTemp: Boolean = true, NumPartitions: Integer = null): (issue #24) Se agrega parámetro NumPartitions para señalar la cantidad de particiones que utilizará spark para almacenar el resultado temporal del DataFrame.

Mejoras / Optimizaciones

A continuación el detalle de las mejoras sobre la versión:

  • Mensajes de fin de proceso en modo control off: Se muestra mensaje de término cuando RegisterInControl=false. El comportamiento anterior no mostraba el mensaje de término por consola.

  • Issue #25: Se agrega validación de las variables requeridas en GlobalSettings. Si alguna de las variables obligatorias no está con valor definido, el programa enviará un error controlado señalado el problema.

  • Issue #27: El modelo de control ahora agrega el tiempo transcurrido en el mensaje de término de procesos enviado por consola.

Release 1.2

A continuación se detallas los cambios de este release.

Nuevo comportamiento en la versión 1.2

Supongamos que tenemos la tabla tbl_nombre_tabla. Si al aplicar data quality sobre las filas de dicha tabla se detectan errores (error o warning), el detalle de las filas que no cumplen con la condición se guardan en una nueva tabla llamada tbl_nombre_tabla_dq (mismo nombre definido por el usuario, se agrega "_dq" al final. Esta tabla tiene las siguientes columnas adicionales:

  • dq_control_id: Id del proceso que identifica la ejecución del modelo de control de huemul.
  • dq_error_columnname: nombre de la columna sobre la cual se aplica la calidad de datos (puede estar en null, depende de la especificación del usuario)
  • dq_error_notification: tipo de notificación (error o warning)
  • dq_error_code: código de error devuelto (según lo indicado por usuario, o Id interno de huemul según sea el caso)
  • dq_error_descripcion: descripción del error indicada por el usuario

El resto de las columnas son idénticas a las que contiene la tabla original.

Cambios en Clases / Funciones

Las siguientes clases y funciones han sufrido modificaciones:

Clase huemul_Table:

  • setSaveDQResult: Nuevo método para indicar si la tabla guarda o no el detalle de errores en DataQuality. El valor por default es "true"
//para evitar guardar el detalle de los errores de DataQuality en la tabla
setSaveDQResult(false)

Clase huemul_DataQuality: Se agrega parámetro "SaveErrorDetails", valor por default "true". En caso de encontrar errores en DataQuality, guarda automáticamente el detalle en la tabla de detalle.

huemul_DataQuality(FieldName: huemul_Columns
            ,Description: String
            ,sqlformula: String
            ,Error_Code: Integer
            ,QueryLevel: huemulType_DQQueryLevel = huemulType_DQQueryLevel.Row //,IsAggregated: Boolean
            ,Notification: huemulType_DQNotification = huemulType_DQNotification.ERROR //RaiseError: Boolean
            ,SaveErrorDetails: Boolean = true

Cambios en GlobalSettings

Se agrega la siguiente configuración:

  • Nombre de base de datos en Hive para consultar el detalle
  • ruta HDFS donde se almacenará detalle de filas con problemas de data quality
   //DQ_ERROR SETTING
   Global.DQ_SaveErrorDetails = true
   Global.DQError_DataBase.append(new huemul_KeyValuePath("production","production_DQError"))
   Global.DQError_DataBase.append(new huemul_KeyValuePath("other_environment","other_DQError"))
   
   Global.DQError_Path.append(new huemul_KeyValuePath("production","hdfs:///user/data/production/dqerror/"))
   Global.DQError_Path.append(new huemul_KeyValuePath("other_environment","hdfs:///user/data/other/dqerror/"))
Clone this wiki locally