/// <summary>
/// Loads a value from the specified buffer.
/// </summary>
/// <param name="buffer">The byte array from which a value should be loaded. The buffer length is always at least equal to the column size.</param>
/// <param name="encoding">The encoding that should be used when loading a value. The encoding is never <c>null</c>.</param>
/// <returns>A column value.</returns>
protected override bool ValueFromRowBuffer(byte[] rowBuffer, ref byte[] cachedColumnData)
{ // This didn't use cachedColumnData, it for MemoColumn only
byte code = rowBuffer[offset_ + 1];
switch (code)
{
case 0x54: // 'T'
case 0x74: // 't'
case 0x59: // 'Y'
case 0x79: // 'y'
return(true);
case 0x46: // 'F'
case 0x66: // 'f'
case 0x4E: // 'N'
case 0x6E: // 'n'
return(false);
case 0x20: // ' '
case 0x3F: // '?'
return(false);
default:
throw ExceptionFactory.CreateArgumentOutOfRangeException(this.name, "Invalid boolean character: '{0}'", code);
}
}
private NdxKeyItem[] KeyPageRead(int pageNo)
{
if ((pageNo < 1) || (pageNo > 0x7FFFFF))
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("pageNo", "NDX index key page position invalid! [{0}]'!", pageNo);
}
int newPosition = pageNo * pageSize;
if ((newPosition + pageSize) > stream.Length)
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("pageNo", "NDX index key page position invalid! (filesize) [{0}]'!", pageNo);
}
bool isRoot = (pageNo == header.rootPage); // if root we must correct this data structure with a 'close' item
stream.Position = newPosition;
BinaryReader reader = new BinaryReader(stream); // don't use 'using (BinaryReader reader...' because 'using' dispose 'stream' too!
int itemsCount = reader.ReadInt32();
NdxKeyItem[] keyItems = new NdxKeyItem[itemsCount + (isRoot ? 1 : 0)];
for (int i = 0; i < itemsCount; i++)
{
NdxKeyItem keyItem = new NdxKeyItem();
keyItem.leftPage = reader.ReadInt32();
keyItem.recNo = reader.ReadInt32();
keyItem.key = reader.ReadBytes(header.keyLen);
if ((header.keyLen % 4) != 0)
{
reader.ReadBytes(4 - (header.keyLen % 4));
}
keyItems[i] = keyItem;
}
if (isRoot)
{
NdxKeyItem keyItem = new NdxKeyItem();
keyItem.leftPage = reader.ReadInt32();
keyItem.recNo = 0;
keyItem.key = new byte[header.keyLen];
for (int i = 0; i < keyItem.key.Length; i++)
{ // fill all bytes of array
keyItem.key[i] = 0xFF;
}
keyItems[itemsCount] = keyItem;
}
return(keyItems);
}
public static NdxHeader GetHeader(Stream stream)
{
if (stream.Length < (pageSize * 2))
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "NDX index stream length '{0}' < '{1}'!", stream.Length, (pageSize * 2));
}
if ((stream.Length % pageSize) != 0)
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "NDX index stream length ({0}) isn't a multiple of '{1}'!", stream.Length, pageSize);
}
//
NdxHeader header = new NdxHeader();
stream.Position = 0;
BinaryReader reader = new BinaryReader(stream); // don't use 'using (BinaryReader reader...' because 'using' dispose 'stream' too!
header.rootPage = reader.ReadInt32();
header.totalPages = reader.ReadInt32();
reader.ReadInt32(); // reserved space
header.keyLen = reader.ReadUInt16();
header.keyPages = reader.ReadUInt16();
header.keyType = reader.ReadUInt16();
header.keyRecSize = reader.ReadInt32(); // Size of key record is a multiplum of 4. Record size is 4 (Pointer to next page) + 4 (record number i dbf) + key size ( as a multiplum of 4 ). i.e. if the key size is 10, the record size is 20 (4+4+12)
{
int extraSpace = header.keyLen % 4;
if (extraSpace != 0)
{
extraSpace += (4 - extraSpace);
}
header.keyRecSize = 4 + 4 + header.keyLen + extraSpace; // rewrite readed value because it was a not valid value
}
reader.ReadByte(); // reserved space
header.unique = reader.ReadBoolean();
header.keyExpr = reader.ReadBytes(maxKeyLen);
if (ProcessKeyExpressionBuffer(header.keyExpr) == null)
{
throw ExceptionFactory.CreateNotSupportedException("Content of NDX key expression bytes is envalid!");
}
return(header);
}
public IColumn FindColumnByName(string columnName)
{
if (String.IsNullOrWhiteSpace(columnName))
{
throw new ArgumentNullException("columnName");
}
var column = _columns.FirstOrDefault(c => (String.Compare(c.name, columnName, true) == 0)); // case insensitive
if (column == null)
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("columnName", "Column {0} not found.", columnName);
}
return(column);
}
protected DbfTable(Stream stream, DbfTableParameters parameters)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!stream.CanRead)
{
throw ExceptionFactory.CreateArgumentException("stream", "The stream does not allow reading (CanRead property returns false).");
}
if (!stream.CanSeek)
{
throw ExceptionFactory.CreateArgumentException("stream", "The stream does not allow reading (CanSeek property returns false).");
}
this._stream = stream;
this.parameters = parameters;
RefreshHeaderInfo();
//
if (this.parameters.encoding == null)
{
this.parameters.encoding = ReadDbfHeader_Encoding(_header.codepageCode);
if (this.parameters.encoding == null)
{
throw new Exception("DbfTable: the DBF file don't contains codepage information!");
}
}
this._columns = ReadDbfColumns(_stream, this.parameters.encoding, _header.newHeaderStructure, this.parameters.openMemo);
//
int calcLen = _header.firstRecordPosition + (_header.recCount * _header.rowLength) + 1;
if ((stream.Length < calcLen - 1) || (stream.Length > calcLen + 1))
{ // dBase & Clipper different (There is or there isn't a 0x1F character at end of DBF data file .
throw ExceptionFactory.CreateArgumentOutOfRangeException("DBF table", "Datafile length error! [got: {0} expected: {1}]", stream.Length, calcLen);
}
}
public IColumn FindColumnByName(string columnName, bool nullReturnEnable)
{ // There isn't default parameter value, so this function is wrote same as previous function, because this way is quicker then call it only with name parameter.
if (String.IsNullOrWhiteSpace(columnName))
{
throw new ArgumentNullException("columnName");
}
var column = _columns.FirstOrDefault(c => (String.Compare(c.name, columnName, true) == 0)); // case insensitive
if (column == null)
{
if (!nullReturnEnable)
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("columnName", "Column {0} not found.", columnName);
}
}
return(column);
}
private void Resize(int newPageCount)
{
if (newPageCount > MAXCACHESIZE)
{
newPageCount = MAXCACHESIZE;
}
else if (newPageCount < 0)
{
newPageCount = 0;
#if DEBUG
throw ExceptionFactory.CreateArgumentOutOfRangeException("newPageCount", "Count of pages must greater or equal then 0!");
#endif
}
if (items.Count > newPageCount)
{ // Shrink size, remove oldest/not-used items
RemovePages(items.Count - newPageCount);
}
_pageCount = newPageCount;
}
public static NtxHeader GetHeader(Stream stream)
{
if (stream.Length < (pageSize * 2))
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "NTX index stream length '{0}' < '{1}'!", stream.Length, (pageSize * 2));
}
if ((stream.Length % pageSize) != 0)
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "NTX index stream length ({0}) isn't a multiple of '{1}'!", stream.Length, pageSize);
}
//
NtxHeader header = new NtxHeader();
stream.Position = 0;
BinaryReader reader = new BinaryReader(stream); // don't use 'using (BinaryReader reader...' because 'using' dispose 'stream' too!
header.signature = reader.ReadUInt16();
header.version = reader.ReadUInt16();
header.root = reader.ReadInt32();
header.unused = reader.ReadInt32();
header.itemSize = reader.ReadUInt16();
header.keySize = reader.ReadUInt16();
header.keyDec = reader.ReadUInt16();
header.maxItem = reader.ReadUInt16();
header.halfPage = reader.ReadUInt16();
header.keyExpr = reader.ReadBytes(maxKeyLen);
byte uniqueFlag = reader.ReadByte();
header.unique = (uniqueFlag != 0);
Debug.Assert(reader.BaseStream.Position == 279);
//
byte sign1Byte = (byte)(header.signature >> 8); // get first byte
if (!Array.Exists(validSignatures, s => (s == sign1Byte)))
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "Signature byte of NTX index stream is invalid! '{0}'", sign1Byte);
}
byte sign2Byte = (byte)(header.signature); // cut off first byte
if (sign2Byte != 0)
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "Second signature byte in NTX index stream header is invalid!'{0}'", sign2Byte);
}
if ((header.keySize < 1) || (header.keySize > 250))
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "Key size in NTX index stream header is invalid!");
}
if ((header.keySize + 8) != header.itemSize)
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "Key size (+8) in NTX index stream header is invalid!");
}
if (ProcessKeyExpressionBuffer(header.keyExpr) == null)
{
throw ExceptionFactory.CreateNotSupportedException("Content of key expression bytes is envalid!");
}
if (!((uniqueFlag == 0) || (uniqueFlag == 1)))
{
throw ExceptionFactory.CreateArgumentOutOfRangeException("stream", "Unique flag in NTX index stream header is invalid!");
}
//
return(header);
}