示例#1
0
        /// <summary>
        ///		Obtiene la cadena de comparación de campos
        /// </summary>
        private string GetSqlCompareFields(ConnectionTableModel table, ScriptsValidationOptions options)
        {
            string sql = string.Empty;

            // Añade la comparación de campos
            foreach (ConnectionTableFieldModel field in table.Fields)
            {
                string nullValue   = GetDefaultNullValue(field.Type);
                string sourceField = $"IfNull({Provider.SqlHelper.FormatName("Target", field.Name)}, {nullValue})";
                string targetField = $"IfNull({GetSqlReplaceField("Test", field, options)}, {nullValue})";

                // Añade el operador si es necesario
                if (!string.IsNullOrWhiteSpace(sql))
                {
                    sql += "\t\t\t\tAND ";
                }
                // Si estamos comparando texto, en caso que queramos sólo comparar caracteres alfanuméricos o dígitos le añade el RegEx
                if (field.Type == ConnectionTableFieldModel.Fieldtype.String && options.CompareOnlyAlphaAndDigits)
                {
                    sourceField = GetSqlRegexAlphaAndDigits(sourceField);
                    targetField = GetSqlRegexAlphaAndDigits(targetField);
                }
                // Añade la comparación
                sql += $"{sourceField} = {targetField}" + Environment.NewLine;
            }
            // Devuelve la cadena SQL
            return(sql);
        }
示例#2
0
        /// <summary>
        ///		Carga el esquema de la conexión
        /// </summary>
        internal async Task LoadSchemaAsync(ConnectionModel connection, CancellationToken cancellationToken)
        {
            SchemaDbModel schema = await GetDbProvider(connection).GetSchemaAsync(TimeSpan.FromMinutes(5), cancellationToken);

            // Limpia las tablas de la conexión
            connection.Tables.Clear();
            // Agrega los campos
            foreach (TableDbModel tableSchema in schema.Tables)
            {
                ConnectionTableModel table = new ConnectionTableModel(connection);

                // Asigna las propiedades
                table.Name        = tableSchema.Name;
                table.Description = tableSchema.Description;
                table.Schema      = tableSchema.Schema;
                // Asigna los campos
                foreach (FieldDbModel fieldSchema in tableSchema.Fields)
                {
                    ConnectionTableFieldModel field = new ConnectionTableFieldModel(table);

                    // Asigna las propiedades
                    field.Name        = fieldSchema.Name;
                    field.Description = fieldSchema.Description;
                    field.Type        = fieldSchema.DbType;                                      // fieldSchema.Type.ToString();
                    field.Length      = fieldSchema.Length;
                    field.IsRequired  = fieldSchema.IsRequired;
                    field.IsKey       = fieldSchema.IsKey;
                    field.IsIdentity  = fieldSchema.IsIdentity;
                    // Añade el campo
                    table.Fields.Add(field);
                }
                // Añade la tabla a la colección
                connection.Tables.Add(table);
            }
        }
示例#3
0
        /// <summary>
        ///		Convierte una vista / tabla
        /// </summary>
        private ConnectionTableModel Convert(ConnectionModel connection, BaseTableDbModel baseTableView)
        {
            ConnectionTableModel view = new ConnectionTableModel(connection);

            // Asigna las propiedades
            view.Name        = baseTableView.Name;
            view.Description = baseTableView.Description;
            view.Schema      = baseTableView.Schema;
            // Asigna los campos
            foreach (FieldDbModel fieldSchema in baseTableView.Fields)
            {
                ConnectionTableFieldModel field = new ConnectionTableFieldModel(view);

                // Asigna las propiedades
                field.Name        = fieldSchema.Name;
                field.Description = fieldSchema.Description;
                field.TypeText    = fieldSchema.DbType;                              // fieldSchema.Type.ToString();
                field.Type        = Convert(fieldSchema.Type);
                field.Length      = fieldSchema.Length;
                field.IsRequired  = fieldSchema.IsRequired;
                field.IsKey       = fieldSchema.IsKey;
                field.IsIdentity  = fieldSchema.IsIdentity;
                // Añade el campo
                view.Fields.Add(field);
            }
            // Devuelve los datos
            return(view);
        }
示例#4
0
        /// <summary>
        ///		Obtiene la cadena de validación sobre un archivo
        /// </summary>
        internal string GetSqlValidateFile(ConnectionTableModel table, bool countRecords, ScriptsValidationOptions options)
        {
            string sql = string.Empty;

            // Crea la cadena SQL de comparación si hay algún campo en la tabla
            if (table.Fields.Count > 0)
            {
                if (countRecords)
                {
                    sql = "\tSELECT COUNT(*) AS Number";
                }
                else
                {
                    sql = "\t" + GetSqlHeaderCompare(table, "Test", "Target");
                }
                sql += Environment.NewLine + $"\t\tFROM {GetFileNameTable(options.MountPathVariable, options.SubpathValidate, table.Name, options.FormatType, options.TablePrefixes)} AS Test";
                sql += Environment.NewLine + "\t\tFULL OUTER JOIN {{" + options.DataBaseComputeVariable + "}}." + Provider.SqlHelper.FormatName(table.Name) + " AS Target";
                sql += Environment.NewLine + "\t\t\tON " + GetSqlCompareFields(table, options).Trim();
                sql += Environment.NewLine + $"\t\tWHERE {Provider.SqlHelper.FormatName("Target", table.Fields[0].Name)} IS NULL";
                sql += Environment.NewLine + $"\t\t\tOR {Provider.SqlHelper.FormatName("Test", table.Fields[0].Name)} IS NULL";
                sql += Environment.NewLine;
            }
            // Devuelve la cadena SQL
            return(sql);
        }
示例#5
0
        /// <summary>
        ///		Obtiene la SQL de la consulta sobre el archivo de QlikView
        /// </summary>
        private string GetSqlQlikView(EtlFilesGenerator generator, ConnectionTableModel table)
        {
            string sql = "LOAD ";

            // Añade los campos de la tabla
            sql += GetQlikViewFields(table, "1 AS Flag_QV", true) + Environment.NewLine;
            // Añade el nombre de tabla
            sql += $" FROM [{Options.MountPathContent}/{generator.RemovePrefix(table.Name, Options.TablePrefixes)}.qvd] (qvd);" + Environment.NewLine;
            // Devuelve la cadena
            return(sql);
        }
示例#6
0
        /// <summary>
        ///		Obtiene la cadena SQL de validación de tablas
        /// </summary>
        private string GetSqlValidation(EtlFilesGenerator generator, ConnectionTableModel table, bool prepareCountTables)
        {
            switch (Options.Mode)
            {
            case ScriptsValidationOptions.ValidationMode.Files:
                return(generator.GetSqlValidateFile(table, prepareCountTables, Options));

            default:
                throw new Exception("Not implemented");
            }
        }
示例#7
0
 /// <summary>
 ///		Obtiene el nombre de la tabla de validación
 /// </summary>
 private string GetValidateTableName(ConnectionTableModel table, bool prepareCountTables)
 {
     if (prepareCountTables)
     {
         return($"{table.Name}_Validate_Count");
     }
     else
     {
         return($"{table.Name}_Validate");
     }
 }
示例#8
0
 public NodeTableViewModel(TreeSolutionBaseViewModel trvTree, NodeConnectionViewModel parent, ConnectionTableModel table, bool isTable) :
     base(trvTree, parent, table.FullName, TreeConnectionsViewModel.NodeType.Table.ToString(),
          TreeConnectionsViewModel.IconType.Table.ToString(), table, true, true, BauMvvm.ViewModels.Media.MvvmColor.Navy)
 {
     Table   = table;
     IsTable = isTable;
     if (!IsTable)
     {
         Icon = TreeConnectionsViewModel.IconType.View.ToString();
     }
 }
示例#9
0
        /// <summary>
        ///		Obtiene la SQL de la consulta de la tabla en Spark
        /// </summary>
        private string GetSqlSelectSparkForQlikView(ConnectionTableModel table)
        {
            string sql = "LOAD ";

            // Añade los campos de la tabla
            sql += GetQlikViewFields(table, "Flag_Spark", true) + ";" + Environment.NewLine;
            // Añade la consulta de carga de base de datos
            sql += "SQL SELECT " + GetQlikViewFields(table, "1 AS Flag_Spark", false) + Environment.NewLine;
            // Añade el nombre de tabla
            sql += $" FROM Spark.{Options.DataBaseComputeVariable}.`{table.Name}`;" + Environment.NewLine;
            // Devuelve la cadena
            return(sql);
        }
示例#10
0
        /// <summary>
        ///		Obtiene la cadena SQL de la cabecera con los campos a visualizar
        /// </summary>
        private string GetSqlHeaderCompare(ConnectionTableModel table, string sourceAlias, string targetAlias)
        {
            string sql = string.Empty;

            // Crea la cabecera con los nombres de campos
            foreach (ConnectionTableFieldModel field in table.Fields)
            {
                sql = sql.AddWithSeparator(Provider.SqlHelper.FormatName(sourceAlias, field.Name + "_" + sourceAlias), ",");
                sql = sql.AddWithSeparator(Provider.SqlHelper.FormatName(targetAlias, field.Name + "_" + targetAlias), ",");
            }
            // Devuelve la cadena creada
            return("SELECT " + sql);
        }
        /// <summary>
        ///		Obtiene la SQL para paginar una consulta en Spark
        /// </summary>
        private string GetSparkPaginatedSql(IDbProvider provider, ConnectionTableModel table, int actualPage, long blockSize)
        {
            string nameRowId = provider.SqlHelper.FormatName($"##_Row_Number_{table.Schema}_{table.Name}##");
            string sqlFields = string.Empty;

            // Obtiene los nombres de campo
            foreach (ConnectionTableFieldModel field in table.Fields)
            {
                sqlFields = sqlFields.AddWithSeparator(provider.SqlHelper.FormatName(field.Name), ",");
            }
            // Devuelve la cadena SQL
            return(@$ "SELECT {sqlFields}
							FROM (SELECT Row_Number() OVER (ORDER BY 1 ASC) AS {nameRowId}, {sqlFields} 
        /// <summary>
        ///		Obtiene una consulta sobre una tabla
        /// </summary>
        private string GetQuery(ConnectionTableModel table)
        {
            if (table == null)
            {
                return(string.Empty);
            }
            else
            {
                (string start, string end)separators = GetSqlSeparators(table.Connection);

                // Devuelve la consulta
                return($"SELECT {GetSqlSelectFields(separators, table)}{Environment.NewLine}\tFROM {GetSqlName(separators, table.Schema, table.Name)}{Environment.NewLine}");
            }
        }
示例#13
0
        /// <summary>
        ///		Obtiene la cadena de comparación de campos
        /// </summary>
        private string GetSqlCompareFields(ConnectionTableModel table)
        {
            string sql = string.Empty;

            // Añade la comparación de campos
            foreach (ConnectionTableFieldModel field in table.Fields)
            {
                // Añade el operador si es necesario
                if (!string.IsNullOrWhiteSpace(sql))
                {
                    sql += "\t\t\t\t\t\tAND ";
                }
                // Añade la comparación
                sql += $"IfNull(Target.`{field.Name}`, '') = IfNull(Test.`{field.Name}`, '')" + Environment.NewLine;
            }
            // Devuelve la cadena SQL
            return(sql);
        }
示例#14
0
        /// <summary>
        ///		Obtiene la cadena SQL de comparación de tablas
        /// </summary>
        private string GetSqlCompare(ConnectionTableModel table, string pathVariable, string databaseVariable, string sufixTestTables)
        {
            string sql = string.Empty;

            // Crea la cadena SQL de comparación si hay algún campo en la tabla
            if (table.Fields.Count > 0)
            {
                sql += Environment.NewLine + "\t\t\tSELECT COUNT(*) AS Number";
                sql += Environment.NewLine + "\t\t\t\tFROM parquet.`{{" + pathVariable + "}}" + $"/testing/{table.Name}{sufixTestTables}.parquet` AS Test";
                sql += Environment.NewLine + "\t\t\t\tFULL OUTER JOIN {{" + databaseVariable + "}}.`" + table.Name + "` AS Target";
                sql += Environment.NewLine + "\t\t\t\t\tON " + GetSqlCompareFields(table).Trim();
                sql += Environment.NewLine + $"\t\t\t\tWHERE Target.`{table.Fields[0].Name}` IS NULL";
                sql += Environment.NewLine + $"\t\t\t\t\tOR Test.`{table.Fields[0].Name}` IS NULL";
                sql += Environment.NewLine;
            }
            // Devuelve la cadena SQL
            return(sql);
        }
        /// <summary>
        ///		Exporta una tabla particionando la consulta en varios <see cref="IDataReader"/> (porque por ejemplo spark carga todo el dataReader en memoria
        ///	y da un error de OutOfMemory)
        /// </summary>
        private void ExportTable(BlockLogModel block, ConnectionModel connection, ConnectionTableModel table, string path,
                                 SolutionManager.FormatType formatType, long blockSize)
        {
            IDbProvider provider   = Manager.DbScriptsManager.GetDbProvider(connection);
            long        records    = 0;
            int         totalPages = 1;

            // Si es una conexión a Spark, se va a paginar si se supera el número de registros por blogue
            if (connection.Type == ConnectionModel.ConnectionType.Spark)
            {
                records = provider.GetRecordsCount($"SELECT * FROM {provider.SqlHelper.FormatName(table.Schema, table.Name)}",
                                                   null, connection.TimeoutExecuteScript) ?? 0;
                totalPages = (int)Math.Ceiling((double)(records / blockSize)) + 1;
            }
            // Obtiene los datos
            for (int actualPage = 0; actualPage < totalPages; actualPage++)
            {
                string fileName;
                string sql;

                // Obtiene el nombre de archivo
                if (totalPages == 1)
                {
                    fileName = GetFileName(path, table.Name, formatType);
                }
                else
                {
                    fileName = GetFileName(path, table.Name, formatType, actualPage + 1);
                }
                // Graba el archivo de la página adecuada
                if (totalPages == 1)
                {
                    sql = $"SELECT * FROM {provider.SqlHelper.FormatName(table.Schema, table.Name)}";
                }
                else
                {
                    sql = GetSparkPaginatedSql(provider, table, actualPage, blockSize);
                }
                //Log
                block.Info($"Reading page {actualPage + 1} / {records / blockSize + 1:#,##0} ({records:#,##0}) from table {table.Name}");
                // Exporta la tabla
                ExportTable(block, provider, sql, fileName, formatType, connection.TimeoutExecuteScript);
            }
        }
示例#16
0
        /// <summary>
        ///		Obtiene una cadena con los campos
        /// </summary>
        private string GetQlikViewFields(ConnectionTableModel table, string additionalField, bool addText)
        {
            string sql = string.Empty;

            // Añade los campos a la cadena
            foreach (ConnectionTableFieldModel field in table.Fields)
            {
                string fieldText = field.Name;

                // Añade la conversión a texto de QlikView
                if (addText && field.Type == ConnectionTableFieldModel.Fieldtype.Integer)
                {
                    fieldText = $"TEXT({fieldText}) AS {fieldText}";
                }
                // Añade el separador
                if (!string.IsNullOrWhiteSpace(sql))
                {
                    sql += ", " + Environment.NewLine + "\t";
                }
                // Añade el campo
                sql += fieldText;
            }
            // Añade el campo adicional si es necesario
            if (!string.IsNullOrWhiteSpace(additionalField))
            {
                // Añade el separador
                if (!string.IsNullOrWhiteSpace(sql))
                {
                    sql += ", ";
                }
                // Añade el campo adicional
                sql += additionalField;
            }
            // Devuelve la cadnea SQL
            return(sql);
        }
 public NodeTableViewModel(BaseTreeViewModel trvTree, NodeConnectionViewModel parent, ConnectionTableModel table) :
     base(trvTree, parent, table.FullName, NodeType.Table, IconType.Table, table, true, true, BauMvvm.ViewModels.Media.MvvmColor.Navy)
 {
     Table = table;
 }
 /// <summary>
 ///		Abre una consulta
 /// </summary>
 private void OpenQuery(ConnectionTableModel table)
 {
     SolutionViewModel.MainController.OpenWindow(new Details.Queries.ExecuteQueryViewModel(SolutionViewModel, table?.Connection.Name, GetQuery(table)));
 }