public SqlRandomTable(SqlRandomTableColumn[] columns, int? primaryKeyColumnIndex = null, int estimatedRowCount = 0)
        {
            if (columns == null || columns.Length == 0)
                throw new ArgumentException("non-empty type array is required");
            if (estimatedRowCount < 0)
                throw new ArgumentOutOfRangeException("non-negative row count is required, use 0 for default");
            if (primaryKeyColumnIndex.HasValue && (primaryKeyColumnIndex.Value < 0 || primaryKeyColumnIndex.Value >= columns.Length))
                throw new ArgumentOutOfRangeException("primaryColumnIndex");

            PrimaryKeyColumnIndex = primaryKeyColumnIndex;
            _columns = (SqlRandomTableColumn[])columns.Clone();
            _columnNames = new string[columns.Length];
            if (estimatedRowCount == 0)
                _rows = new List<object[]>();
            else
                _rows = new List<object[]>(estimatedRowCount);

            Columns = new List<SqlRandomTableColumn>(_columns).AsReadOnly();
            ColumnNames = new List<string>(_columnNames).AsReadOnly();
            bool hasSparse = false;
            double totalNonSparse = 0;
            foreach (var c in _columns)
            {
                if (c.IsSparse)
                {
                    hasSparse = true;
                }
                else
                {
                    totalNonSparse += c.GetInRowSize(null); // for non-sparse columns size does not depend on the value
                }
            }
            HasSparseColumns = hasSparse;
            NonSparseValuesTotalSize = totalNonSparse;
        }

 protected override string GetTSqlTypeDefinitionInternal(SqlRandomTableColumn columnInfo)
 {
     string sizeSuffix;
     if (!columnInfo.StorageSize.HasValue)
     {
         sizeSuffix = DefaultSize.ToString();
     }
     else
     {
         int size = columnInfo.StorageSize.Value;
         if (size > MaxDefinedSize)
         {
             sizeSuffix = "max";
         }
         else
         {
             Debug.Assert(size > 0, "wrong size");
             sizeSuffix = size.ToString();
         }
     }
     return string.Format("{0}({1})", TypePrefix, sizeSuffix);
 }

 protected override bool CompareValuesInternal(SqlRandomTableColumn columnInfo, object expected, object actual)
 {
     if ((columnInfo.Options & SqlRandomColumnOptions.ColumnSet) != 0)
     {
         throw new InvalidOperationException("should not be used for ColumnSet columns - use CanCompareValues before calling this method");
     }
     return CompareCharArray(expected, actual, allowIncomplete: false);
 }

 protected override object ReadInternal(DbDataReader reader, int ordinal, SqlRandomTableColumn columnInfo, Type asType)
 {
     return ReadByteArray(reader, ordinal, asType);
 }

 protected override double GetInRowSizeInternal(SqlRandomTableColumn columnInfo)
 {
     return GetCharSize(columnInfo) * 2; // nchar is not stored in row
 }

        private int GetCharSize(SqlRandomTableColumn columnInfo)
        {
            ValidateColumnInfo(columnInfo);

            int charSize = columnInfo.StorageSize.HasValue ? columnInfo.StorageSize.Value / 2 : DefaultCharSize;
            if (charSize < 1 || charSize > MaxCharSize)
                throw new NotSupportedException("wrong size");

            return charSize;
        }

 protected override object CreateRandomValueInternal(SqlRandomizer rand, SqlRandomTableColumn columnInfo)
 {
     int size = columnInfo.StorageSize.HasValue ? columnInfo.StorageSize.Value : DefaultCharSize;
     return rand.NextAnsiArray(0, size);
 }

 public override bool CanCompareValues(SqlRandomTableColumn columnInfo)
 {
     // completely ignore TIMESTAMP value comparison
     return false;
 }