public Row[] Read(IEnumerable <Row> input)
        {
            var results = new List <Row>();

            using (var cn = new SqlConnection(_context.Connection.GetConnectionString())) {
                cn.Open();
                var trans = cn.BeginTransaction();

                cn.Execute(_create, null, trans);

                var keys = input.Select(r => r.ToExpandoObject(_keys));
                cn.Execute(_insert, keys, trans, _context.Connection.Timeout, System.Data.CommandType.Text);

                using (var reader = cn.ExecuteReader(_query, null, trans, _context.Connection.Timeout, System.Data.CommandType.Text)) {
                    while (reader.Read())
                    {
                        var row = _rowCreator.Create(reader, _rowCapacity, _fields);
                        row.TflHashCode = (int)row[_hashCode];
                        results.Add(row);
                    }
                }

                cn.Execute(_drop, null, trans);
                trans.Commit();
            }
            return(results.ToArray());
        }
Ejemplo n.º 2
0
        public IEnumerable <Row> Read()
        {
            var batches    = _process.Entities.Select(e => e.BatchId).ToArray();
            var minBatchId = batches.Min();
            var maxBatchId = batches.Max();

            _output.Info("Batch Range: {0} to {1}.", minBatchId, maxBatchId);

            var sql = $"SELECT {string.Join(",", _output.Entity.Fields.Select(f => "[" + f.Alias + "]"))} FROM [{_output.Process.Star}] WITH (NOLOCK) WHERE [TflBatchId] BETWEEN @MinBatchId AND @MaxBatchId;";

            _output.Debug(sql);

            using (var cn = new SqlConnection(_output.Connection.GetConnectionString())) {
                cn.Open();
                var cmd = cn.CreateCommand();

                cmd.CommandTimeout = 0;
                cmd.CommandType    = CommandType.Text;
                cmd.CommandText    = sql;
                cmd.Parameters.AddWithValue("@MinBatchId", minBatchId);
                cmd.Parameters.AddWithValue("@MaxBatchId", maxBatchId);

                var reader     = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
                var rowCount   = 0;
                var fieldArray = _output.Entity.Fields.ToArray();
                while (reader.Read())
                {
                    rowCount++;
                    yield return(_rowCreator.Create(reader, fieldArray.Length + _output.Entity.CalculatedFields.Count, fieldArray));
                }
                _output.Info("{0} from {1}", rowCount, _output.Connection.Name);
            }
        }
Ejemplo n.º 3
0
        public IEnumerable <Row> Read()
        {
            using (var cn = new SqlConnection(_connection.GetConnectionString())) {
                cn.Open();
                var cmd = cn.CreateCommand();

                cmd.CommandTimeout = 0;
                cmd.CommandType    = CommandType.Text;
                cmd.CommandText    = $"SELECT [{string.Join("],[", _fields.Select(f => _readFrom == ReadFrom.Output ? f.FieldName() : f.Name))}] FROM [{_tableOrView}] WITH (NOLOCK);";
                _context.Debug(cmd.CommandText);

                var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess);

                while (reader.Read())
                {
                    _rowCount++;
                    yield return(_rowCreator.Create(reader, _fields.Length, _fields));
                }
                _context.Info("{0} from {1}", _rowCount, _connection.Name);
            }
        }
Ejemplo n.º 4
0
        public IEnumerable <Row> Read()
        {
            using (var cn = new SqlConnection(_input.Connection.GetConnectionString())) {
                cn.Open();
                var cmd = cn.CreateCommand();

                if (_input.Entity.MaxVersion == null)
                {
                    cmd.CommandText = _input.SqlSelectInput(_fields);
                }
                else
                {
                    if (_input.Entity.MinVersion == null)
                    {
                        cmd.CommandText = _input.SqlSelectInputWithMaxVersion(_fields);
                        cmd.Parameters.AddWithValue("@MaxVersion", _input.Entity.MaxVersion);
                    }
                    else
                    {
                        cmd.CommandText = _input.SqlSelectInputWithMinAndMaxVersion(_fields);
                        cmd.Parameters.AddWithValue("@MinVersion", _input.Entity.MinVersion);
                        cmd.Parameters.AddWithValue("@MaxVersion", _input.Entity.MaxVersion);
                    }
                }

                cmd.CommandType    = CommandType.Text;
                cmd.CommandTimeout = _input.Connection.Timeout;

                var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess);

                while (reader.Read())
                {
                    _rowCount++;
                    _input.Increment();
                    yield return(_rowCreator.Create(reader, _input.RowCapacity, _fields));
                }
                _input.Info("{0} from {1}", _rowCount, _input.Connection.Name);
            }
        }
        public IEnumerable <Row> Read(IEnumerable <Row> input)
        {
            using (var cn = new SqlConnection(_input.Connection.GetConnectionString())) {
                cn.Open();
                var trans = cn.BeginTransaction();

                cn.Execute(_create, null, trans);

                var keys = input.Select(r => r.ToExpandoObject(_keys));
                cn.Execute(_insert, keys, trans, _input.Connection.Timeout, System.Data.CommandType.Text);

                using (var reader = cn.ExecuteReader(_query, null, trans, _input.Connection.Timeout, System.Data.CommandType.Text)) {
                    while (reader.Read())
                    {
                        yield return(_rowCreator.Create(reader, _input.RowCapacity, _input.InputFields));
                    }
                }

                cn.Execute(_drop, null, trans);
                trans.Commit();
            }
        }