protected override void Initialise(XElement configXML, GlobalData globalData, ILogger logger)
        {
            if (configXML == null)
            {
                throw new ConfigException("Missing Config");
            }

            var tablename = configXML.Attribute("tablename")?.Value;

            if (tablename == null)
            {
                throw new ConfigException("Missing Table name");
            }

            lock (_initialisationObject)
            {
                if (!globalData.CacheDataSet.Tables.Contains(tablename))
                {
                    logger.Debug(string.Format("Pipe {0}: {1} Already initailised", PipeNumber, nameof(CacheTableLoader)));
                    return;
                }

                try
                {
                    _loggingTable = DataTableBuilder.Build(configXML);
                }
                catch (Exception ex)
                {
                    throw new ConfigException("Invalid Configuration: " + ex.Message);
                }

                globalData.CacheDataSet.Tables.Add(_loggingTable.Table);
            }
        }
        public static MappedDataTable Build(XElement configXML)
        {
            var tablename = configXML.Attribute("tablename")?.Value;

            if (string.IsNullOrWhiteSpace(tablename))
            {
                throw new Exception("Missing table name");
            }

            var loggingTable = new MappedDataTable()
            {
                Table          = new DataTable(tablename),
                ColumnMappings = new Dictionary <string, string>(),
            };

            var columns = configXML.Element("columns");

            if (columns == null || columns.Elements("column").Count() == 0)
            {
                throw new Exception("Missing column definition");
            }

            foreach (var column in columns.Elements("column"))
            {
                var name   = column.Attribute("name")?.Value;
                var type   = column.Attribute("type")?.Value;
                var format = column.Attribute("format")?.Value;
                var map    = string.IsNullOrWhiteSpace(column.Attribute("map")?.Value) ? name.ToLower() : column.Attribute("map").Value;

                loggingTable.ColumnMappings.Add(name, map);

                if (string.IsNullOrWhiteSpace(type))
                {
                    throw new Exception(string.Format("Invalid type for column {0}", name));
                }

                loggingTable.Table.Columns.Add(new DataColumn {
                    DataType = TypeConverter.GetType(type), ColumnName = name
                });
            }

            return(loggingTable);
        }
예제 #3
0
        protected override void Initialise(XElement configXML, GlobalData globalData, ILogger logger)
        {
            if (configXML == null)
            {
                throw new ConfigException("Missing Config");
            }

            Interlocked.Increment(ref _activeInstances);

            lock (_initialisationObject)
            {
                if (_initailised)
                {
                    logger.Debug(string.Format("Pipe {0}: {1} Already initailised", PipeNumber, nameof(SQLBulkLoader)));
                    return;
                }

                _tablename = configXML.Attribute("tablename")?.Value;

                if (string.IsNullOrWhiteSpace(_tablename))
                {
                    throw new ConfigException("Missing table name");
                }

                _connStr = configXML.Attribute("connection")?.Value ?? GlobalData.Data["connection"].ToString();

                if (!string.IsNullOrWhiteSpace(configXML.Attribute("batchsize")?.Value) && !int.TryParse(configXML.Attribute("batchsize")?.Value, out _batchSize))
                {
                    throw new ConfigException("Invalid batch size");
                }

                try
                {
                    _loggingTable = DataTableBuilder.Build(configXML);
                }
                catch (Exception ex)
                {
                    throw new ConfigException("Invalid Configuration: " + ex.Message);
                }

                _initailised = true;
            }
        }