Exemplo n.º 1
0
        void IResultWriter.WriteTableBegin(DataTable schemaTable)
        {
            _logResultWriter.WriteTableBegin(schemaTable);

            if (isJsonAuto)
            {
                var column = FoundationDbColumnFactory.Create(schemaTable.Rows[0]);
                isJsonAuto = column.DataType == typeof(string);
            }

            if (isJsonAuto)
            {
                Assert.IsNull(_path);

                var identifier = LocalTime.Default.Now.ToString("yyyy-MM-dd HHmmss.fff");
                var tempPath   = Path.GetTempPath();
                _path          = Path.Combine(tempPath, identifier + ".json");
                _textWriter    = new StreamWriter(_path, false, Encoding.UTF8);
                _formattedPath = Path.Combine(tempPath, identifier + "formatted.json");
                _addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Information, null, $"Formatted JSON file: {_formattedPath}"));
            }
            else
            {
                _addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Error, null, "This is not FOR JSON AUTO"));
            }
        }
Exemplo n.º 2
0
        void IResultWriter.WriteTableBegin(DataTable schemaTable)
        {
            _logResultWriter.WriteTableBegin(schemaTable);

            var path         = Path.GetTempFileName() + ".json";
            var streamWriter = new StreamWriter(path, false, Encoding.UTF8);

            _jsonTextWriter            = new JsonTextWriter(streamWriter);
            _jsonTextWriter.Formatting = Formatting.Indented;
            _jsonTextWriter.WriteStartArray();

            _columns = schemaTable.Rows.Cast <DataRow>().Select(FoundationDbColumnFactory.Create).ToList();
        }
Exemplo n.º 3
0
        void IResultWriter.WriteTableBegin(DataTable schemaTable)
        {
            _logResultWriter.WriteTableBegin(schemaTable);

            var path         = Path.GetTempFileName() + ".html";
            var streamWriter = new StreamWriter(path, false, Encoding.UTF8);

            _htmlTextWriter = new HtmlTextWriter(streamWriter);

            _htmlTextWriter.WriteFullBeginTag("table");
            _htmlTextWriter.WriteLine();
            ++_htmlTextWriter.Indent;

            var columns = schemaTable.Rows.Cast <DataRow>().Select(FoundationDbColumnFactory.Create).ToList();

            _htmlTextWriter.WriteFullBeginTag("tr");
            _htmlTextWriter.WriteLine();
            ++_htmlTextWriter.Indent;

            for (var columnIndex = 0; columnIndex < columns.Count; ++columnIndex)
            {
                var column = columns[columnIndex];

                if (columnIndex > 0)
                {
                    _htmlTextWriter.WriteLine();
                }

                _htmlTextWriter.WriteFullBeginTag("th");
                _htmlTextWriter.WriteEncodedText(column.ColumnName);
                _htmlTextWriter.WriteEndTag("th");
            }

            _htmlTextWriter.WriteLine();
            --_htmlTextWriter.Indent;
            _htmlTextWriter.WriteEndTag("tr");
        }
Exemplo n.º 4
0
    private void ReadTable(IDataReader dataReader, DataTable schemaTable, int tableIndex)
    {
        Assert.IsNotNull(dataReader);
        Assert.IsNotNull(schemaTable);
        Assert.IsInRange(tableIndex >= 0);

        using (LogFactory.Instance.GetCurrentMethodLog())
        {
            Exception exception        = null;
            var       dataReaderHelper = _provider.CreateDataReaderHelper(dataReader);
            var       schemaRows       = schemaTable.Rows;
            var       count            = schemaRows.Count;

            _resultWriter.WriteTableBegin(schemaTable);

            var fieldCount = dataReader.FieldCount;

            if (fieldCount < 0)
            {
                fieldCount = 0;
            }

            var rows = new object[_rowBlockSize][];
            int i;

            for (i = 0; i < _rowBlockSize; i++)
            {
                rows[i] = new object[fieldCount];
            }

            _rowCount = 0;
            i         = 0;
            var first         = true;
            var exitFromWhile = false;
            var stopwatch     = Stopwatch.StartNew();

            while (!_isCommandCancelled && !_thread.IsStopRequested && !exitFromWhile)
            {
                bool read;

                if (first)
                {
                    first = false;
                    _resultWriter.FirstRowReadBegin();
                    read = dataReader.Read();

                    var dataTypeNames = new string[count];

                    if (read)
                    {
                        for (var j = 0; j < count; ++j)
                        {
                            dataTypeNames[j] = dataReader.GetDataTypeName(j);
                        }
                    }

                    _resultWriter.FirstRowReadEnd(dataTypeNames);
                }
                else
                {
                    try
                    {
                        read = dataReader.Read();
                    }
                    catch (Exception e)
                    {
                        read      = false;
                        exception = e;
                    }
                }

                if (read)
                {
                    ++_rowCount;
                    dataReaderHelper.GetValues(rows[i]);
                    ++i;

                    if (i == _rowBlockSize || stopwatch.ElapsedMilliseconds >= 5000)
                    {
                        _resultWriter.WriteRows(rows, i);
                        i = 0;
                        stopwatch.Restart();
                    }

                    if (_rowCount == _maxRecords)
                    {
                        CancelWaitCallback(null);
                        break;
                    }
                }
                else
                {
                    exitFromWhile = true;
                }
            }

            if (i != _rowBlockSize)
            {
                Log.Trace("resultWriter.WriteRows(rows,i);");
                _resultWriter.WriteRows(rows, i);
            }

            Log.Write(LogLevel.Trace, "resultWriter.WriteTableEnd(rowCount);");
            _resultWriter.WriteTableEnd();

            if (_rowCount > 0)
            {
                ++_tableCount;
            }

            if (exception != null)
            {
                throw exception;
            }
        }
    }
Exemplo n.º 5
0
 void IResultWriter.WriteTableBegin(DataTable schemaTable)
 {
     ++_tableIndex;
     _logResultWriter.WriteTableBegin(schemaTable);
     CreateTable(schemaTable);
 }
Exemplo n.º 6
0
 void IResultWriter.WriteTableBegin(DataTable schemaTable)
 {
     _logResultWriter.WriteTableBegin(schemaTable);
     CreateTable(schemaTable);
 }
Exemplo n.º 7
0
        void IResultWriter.WriteTableBegin(DataTable schemaTable)
        {
            _logResultWriter.WriteTableBegin(schemaTable);

            _rowIndex = 0;

            if (schemaTable != null)
            {
                var columnNameColumn = schemaTable.Columns[SchemaTableColumn.ColumnName];
                var columnSizeColumn = schemaTable.Columns["ColumnSize"];
                var dataTypeColumn   = schemaTable.Columns["DataType"];

                var fieldCount = schemaTable.Rows.Count;
                _columnSize = new int[fieldCount];

                var stringBuilder = new StringBuilder();

                for (var i = 0; i < fieldCount; i++)
                {
                    var schemaRow  = schemaTable.Rows[i];
                    var columnName = (string)schemaRow[columnNameColumn];
                    var type       = (Type)schemaRow[dataTypeColumn];
                    var numOfBytes = (int)schemaRow[columnSizeColumn];

                    Type elementType;

                    if (type.IsArray)
                    {
                        elementType = type.GetElementType();

                        if (numOfBytes > 2048)
                        {
                            numOfBytes = 2048;
                        }
                    }
                    else
                    {
                        elementType = type;
                    }

                    var typeCode = Type.GetTypeCode(elementType);

                    int numOfChars;

                    switch (typeCode)
                    {
                    case TypeCode.Byte:
                        if (type.IsArray)
                        {
                            numOfChars = Math.Min(100, numOfBytes) * 2 + 2;
                        }
                        else
                        {
                            numOfChars = 4;
                        }
                        break;

                    case TypeCode.Boolean:
                        numOfChars = 5;
                        break;

                    case TypeCode.Int16:
                        numOfChars = 5;
                        break;

                    case TypeCode.Int32:
                        numOfChars = 11;
                        break;

                    case TypeCode.Double:
                        numOfChars = double.MaxValue.ToString().Length;
                        break;

                    case TypeCode.Decimal:
                        //numOfChars = numOfBytes;
                        var precision = (short)schemaRow["NumericPrecision"];
                        var scale     = schemaRow.Field <short>("NumericScale");
                        numOfChars = precision + 3;
                        break;

                    case TypeCode.DateTime:
                        numOfChars = 23;
                        break;

                    case TypeCode.String:
                        numOfChars = Math.Min(numOfBytes, 2048);
                        break;

                    default:
                        if (elementType == typeof(Guid))
                        {
                            numOfChars = Guid.Empty.ToString().Length;
                        }
                        else
                        {
                            numOfChars = numOfBytes;
                        }

                        break;
                    }

                    _columnSize[i] = Math.Max(numOfChars, columnName.Length);
                    Write(stringBuilder, columnName, _columnSize[i]);
                    stringBuilder.Append(' ');
                }

                _textWriter.WriteLine(stringBuilder.ToString());

                if (fieldCount > 0)
                {
                    stringBuilder = new StringBuilder();
                    var last = fieldCount - 1;

                    for (var i = 0; i < last; i++)
                    {
                        stringBuilder.Append('-', _columnSize[i]);
                        stringBuilder.Append(' ');
                    }

                    stringBuilder.Append('-', _columnSize[last]);

                    _textWriter.WriteLine(stringBuilder.ToString());
                }
            }
        }