Initial community commit

1 files changed, 1196 insertions, 0 deletions

diff --git a/Src/nde/android/Scanner.cpp b/Src/nde/android/Scanner.cpp
new file mode 100644
index 00000000..001cdc8f
--- /dev/null
+++ b/Src/nde/android/Scanner.cpp
@@ -0,0 +1,1196 @@
+/* ---------------------------------------------------------------------------
+Nullsoft Database Engine
+--------------------
+codename: Near Death Experience
+--------------------------------------------------------------------------- */
+
+/* ---------------------------------------------------------------------------
+
+Scanner Class
+
+--------------------------------------------------------------------------- */
+
+#include "../nde.h"
+#include "BinaryField.h"
+#include "Binary32Field.h"
+#include <assert.h>
+//---------------------------------------------------------------------------
+Scanner::Scanner(Table *parentTable)
+{
+	disable_date_resolution=0;
+	index = NULL;
+	pTable = parentTable;
+	Edition=false;
+
+	lastLocateIndex = NULL;
+	lastLocateId = -1;
+	lastLocateIdx = -1;
+	lastLocateFrom = -128;
+	lastLocateFieldClone = NULL;
+	CurrentRecord=NULL;
+	CurrentRecordIdx=0;
+	iModified = false;
+	FiltersOK = false;
+
+	search_any = false;
+	ResultPtr = 0;
+
+	/*inMatchJoins = 0;
+	lastJoinCache = 0;
+	invalidJoinCache = 1;*/
+	last_query = NULL;
+	last_query_failed = false;
+	token = NULL;
+	in_query_parser = 0;
+}
+
+//---------------------------------------------------------------------------
+Scanner::~Scanner()
+{
+	if (CurrentRecord) CurrentRecord->Release();
+
+	if (lastLocateFieldClone)
+	{
+		delete lastLocateFieldClone;
+	}
+
+	Query_CleanUp();
+
+	if (token) ndestring_release(token);
+	ndestring_release(last_query);
+}
+
+//---------------------------------------------------------------------------
+Record *Scanner::GetRecord(int Idx)
+{
+	int Ptr;
+	Ptr = index->Get(Idx);
+
+	Record *r = pTable->RowCache_Get(Ptr);
+	if (r)
+	{
+		return r;
+	}
+
+	r = new Record(Ptr, Idx, pTable->Handle, pTable);
+	pTable->RowCache_Add(r, Ptr);
+	return r;
+}
+
+//---------------------------------------------------------------------------
+void Scanner::GetCurrentRecord(void)
+{
+	/*
+	if (Eof() || Bof()) 
+	{
+	if (CurrentRecord) CurrentRecord->Release();
+	CurrentRecord = NULL;
+	return;
+	}
+
+	Record *old_record = CurrentRecord;
+	CurrentRecord = NULL;
+
+	Record *new_record = GetRecord(CurrentRecordIdx);	
+	if (old_record) old_record->Release();
+	CurrentRecord = new_record;
+	*/
+	if (CurrentRecord) CurrentRecord->Release();
+	CurrentRecord = NULL;
+
+	//invalidJoinCache = 1;
+	if (Eof() || Bof()) return;
+	CurrentRecord = GetRecord(CurrentRecordIdx);
+
+}
+
+//---------------------------------------------------------------------------
+void Scanner::GetRecordById(int Id, bool checkFilters)
+{
+	CurrentRecordIdx=max(min(index->NEntries, Id+NUM_SPECIAL_RECORDS), 0);
+	GetCurrentRecord();
+	if (!checkFilters || MatchFilters())
+		return;
+	Next();
+}
+
+//---------------------------------------------------------------------------
+void Scanner::First(int *killswitch)
+{
+	if (last_query_failed) return;
+	GetRecordById(0);
+	if (!MatchFilters() && !Eof())
+		Next(killswitch);
+}
+
+//---------------------------------------------------------------------------
+int Scanner::Next(int *killswitch)
+{
+	if (last_query_failed) return 0;
+
+	while (!Eof() && !Bof())
+	{
+		CurrentRecordIdx++;
+		GetCurrentRecord();
+		if (MatchFilters())
+			break;
+		else
+		{
+			if ((killswitch && *killswitch))
+				return 0;
+		}
+	}
+	return 1;
+}
+
+//---------------------------------------------------------------------------
+int Scanner::Previous(int *killswitch)
+{
+	if (last_query_failed) return 0;
+
+	while (CurrentRecordIdx >= NUM_SPECIAL_RECORDS)
+	{
+		CurrentRecordIdx--;
+		GetCurrentRecord();
+		if (MatchFilters())
+			break;
+		else
+		{
+			if ((killswitch && *killswitch))
+				return 0;
+		}
+	}
+	return 1;
+}
+
+//---------------------------------------------------------------------------
+void Scanner::Last(int *killswitch)
+{
+	if (last_query_failed) return;
+	GetRecordById(index->NEntries-NUM_SPECIAL_RECORDS-1); // -3 here because 1)GetRecordById is public, so -NUM_SPECIAL_RECORDS, and 2)last entry is nentries-1, so -1
+	if (!MatchFilters() && !Bof())
+		Previous(killswitch);
+	if (CurrentRecordIdx < NUM_SPECIAL_RECORDS)
+	{
+		CurrentRecordIdx = index->NEntries;
+		GetCurrentRecord(); // will only delete current record if it exists
+	}
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::Eof(void)
+{
+	if (last_query_failed) return true;
+	return CurrentRecordIdx >= index->NEntries;
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::Bof(void)
+{
+	if (last_query_failed) return true;
+	return CurrentRecordIdx < NUM_SPECIAL_RECORDS;
+}
+
+//---------------------------------------------------------------------------
+Field *Scanner::GetFieldByName(const char *FieldName)
+{
+	ColumnField *header = pTable->GetColumnByName(FieldName);
+	if (header)
+	{
+		unsigned char Idx = header->ID;
+		return GetFieldById(Idx);
+	}
+	return NULL;
+}
+
+//---------------------------------------------------------------------------
+Field *Scanner::GetFieldById(unsigned char Id)
+{
+	if (!CurrentRecord)
+		return NULL;
+	Field *field = CurrentRecord->GetField(Id);
+	if (field)
+	{
+		int column_type = pTable->GetColumnType(Id);
+		if (!CompatibleFields(field->GetType(), column_type))
+		{
+			return NULL;
+		}
+	}
+	return field;
+}
+
+//---------------------------------------------------------------------------
+Field *Scanner::NewFieldByName(const char *fieldName, unsigned char Perm)
+{
+	ColumnField *header = pTable->GetColumnByName(fieldName);
+	if (header)
+	{
+		unsigned char Id = header->ID;
+		Field *field = NewFieldById(Id, Perm);
+		return field;
+	}
+	return NULL;
+}
+
+//---------------------------------------------------------------------------
+Field *Scanner::NewFieldById(unsigned char Id, unsigned char Perm)
+{
+	ColumnField *field = GetColumnById(Id);
+	if (!field)
+		return NULL;
+	Field *O=GetFieldById(Id);
+	if (O) return O;
+	switch (field->GetDataType())
+	{
+	case FIELD_STRING:
+		O = new StringField();
+		break;
+	case FIELD_INTEGER:
+		O = new IntegerField();
+		break;
+	case FIELD_INT64:
+		O = new Int64Field();
+		break;
+	case FIELD_INT128:
+		O = new Int128Field();
+		break;
+	case FIELD_DATETIME:
+		if (disable_date_resolution)
+			O= new StringField();
+		else
+			O = new DateTimeField();
+		break;
+	case FIELD_LENGTH:
+		O = new LengthField();
+		break;
+	case FIELD_FILENAME:
+		O = new FilenameField();
+		break;
+	case FIELD_BINARY:
+		O = new BinaryField();
+		break;
+	case FIELD_BINARY32:
+		O = new Binary32Field();
+		break;
+	default:
+		//MessageBox(NULL, "unknown field type for id", "debug", 0);
+		O = new Field();
+		break;
+	}
+	O->Type = field->GetDataType();
+	O->ID = Id;
+	CurrentRecord->AddField(O);
+	return O;
+}
+
+//---------------------------------------------------------------------------
+void Scanner::Post(void)
+{
+	if (!CurrentRecord) return;
+	/*if (CurrentRecord->RecordIndex == NEW_RECORD)
+	NEntries++;*/
+	if (pTable->use_row_cache && CurrentRecordIdx != NEW_RECORD)
+	{
+		int Ptr;
+		Ptr = index->Get(CurrentRecordIdx);
+		pTable->RowCache_Remove(Ptr);
+	}
+	CurrentRecordIdx = CurrentRecord->WriteFields(pTable, CurrentRecordIdx);
+	Edition=false;
+	if (pTable->use_row_cache)
+	{
+		int Ptr;
+		Ptr = index->Get(CurrentRecordIdx);
+		pTable->RowCache_Add(CurrentRecord, Ptr);
+	}
+}
+
+//---------------------------------------------------------------------------
+void Scanner::New(void)
+{
+	if (CurrentRecord) CurrentRecord->Release();
+	CurrentRecord = NULL;
+
+	CurrentRecord = new Record(0, index->NEntries, pTable->Handle, pTable);
+	CurrentRecordIdx = NEW_RECORD;
+	Edition = true;
+}
+
+//---------------------------------------------------------------------------
+void Scanner::Insert(void)
+{
+	if (CurrentRecord) CurrentRecord->Release();
+	CurrentRecord = NULL;
+
+	CurrentRecord = new Record(0, CurrentRecordIdx, pTable->Handle, pTable);
+	CurrentRecordIdx = NEW_RECORD;
+	Edition=true;
+}
+
+//---------------------------------------------------------------------------
+void Scanner::Delete(void)
+{
+	if (CurrentRecord)
+	{
+		if (pTable->use_row_cache && CurrentRecordIdx != NEW_RECORD)
+		{
+			int Ptr;
+			Ptr = index->Get(CurrentRecordIdx);
+			pTable->RowCache_Delete(Ptr);
+		}
+		CurrentRecord->Delete(pTable, CurrentRecordIdx);
+	}
+	if (Eof())
+		Previous();
+	GetRecordById(CurrentRecordIdx-NUM_SPECIAL_RECORDS);
+}
+
+//---------------------------------------------------------------------------
+int Scanner::GetRecordId(void)
+{
+	return CurrentRecordIdx != NEW_RECORD ? CurrentRecordIdx-NUM_SPECIAL_RECORDS : CurrentRecordIdx;
+}
+
+//---------------------------------------------------------------------------
+void Scanner::Edit(void)
+{
+	if (Edition) return;
+	if (!CurrentRecord)
+		return;
+	/*Field *f = (Field *)CurrentRecord->Fields->GetHead();
+	while (f)
+	{
+	f->SubtableRecord = INVALID_RECORD;
+	f = (Field *)f->GetNext();
+	}*/
+
+	if (CurrentRecord->InCache()) // if it's in the cache
+	{
+		// benski> make copy of CurrentRecord, outside the cache
+		int Ptr;
+		Ptr = index->Get(CurrentRecordIdx);
+		pTable->RowCache_Remove(Ptr);
+		Record *r = new Record(Ptr, CurrentRecordIdx, pTable->Handle, pTable);
+		CurrentRecord->Release();
+		CurrentRecord = r;
+	}
+
+	Edition = true;
+}
+
+
+//---------------------------------------------------------------------------
+void Scanner::Cancel(void)
+{
+	Edition = false;
+	GetCurrentRecord();
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::LocateByName(const char *col, int From, Field *field, int *nskip)
+{
+	ColumnField *f = pTable->GetColumnByName(col);
+	if (!f)
+		return NULL;
+	return LocateById(f->GetFieldId(), From, field, nskip);
+}
+
+//---------------------------------------------------------------------------
+void Scanner::CacheLastLocate(int Id, int From, Field *field, Index *i, int j)
+{
+	lastLocateId = Id;
+	lastLocateFrom = From;
+	if (lastLocateFieldClone)
+	{
+		delete lastLocateFieldClone;
+		lastLocateFieldClone = NULL;
+	}
+	lastLocateFieldClone = field->Clone(pTable);
+	lastLocateIndex = i;
+	i->locateUpToDate = true;
+	pTable->SetGlobalLocateUpToDate(true);
+	lastLocateIdx = j;
+}
+
+
+//---------------------------------------------------------------------------
+bool Scanner::LocateById(int Id, int From, Field *field, int *nskip)
+{
+	return LocateByIdEx(Id, From, field, nskip, COMPARE_MODE_EXACT);
+}
+//---------------------------------------------------------------------------
+bool Scanner::LocateByIdEx(int Id, int From, Field *field, int *nskip, int comp_mode)
+{
+	IndexField *i = pTable->GetIndexById(Id);
+	Field *compField;
+	int j;
+	int n;
+	Field *cfV;
+
+	if (index->NEntries == NUM_SPECIAL_RECORDS)
+		return false;
+
+	int success;
+
+	if (nskip) *nskip=0;
+	// I know this is stupid but.... May be do something later
+	switch (comp_mode)
+	{
+	case COMPARE_MODE_CONTAINS:
+		while (1)
+		{
+			success = false;
+			if (!i)
+			{
+				// No index for this column. Using slow locate, enumerates the database, still faster than what the user
+				// can do since we have access to QuickFindField which only read field headers
+				// in order to locate the field we have to compare. user could only read the entire record.
+				if (From == FIRST_RECORD)
+					From = NUM_SPECIAL_RECORDS;
+				else
+					From+=(NUM_SPECIAL_RECORDS+1);
+				if (From == lastLocateFrom && Id == lastLocateId && field->Contains(lastLocateFieldClone)==0 && index == lastLocateIndex && (index->locateUpToDate || pTable->GLocateUpToDate))
+				{
+					if (CurrentRecordIdx != lastLocateIdx) GetRecordById(lastLocateIdx-NUM_SPECIAL_RECORDS, false);
+					success = true;
+					goto nextiter_1;
+				}
+				for (j=From;j<index->NEntries;j++)
+				{
+					compField = index->QuickFindField(Id, index->Get(j));
+					cfV = /*(compField && compField->Type == FIELD_PRIVATE) ? ((PrivateField *)compField)->myField :*/ compField;
+					if (!field->Contains(cfV))
+					{
+						if (compField)
+						{
+							delete compField;
+						}
+						if (CurrentRecordIdx != j) GetRecordById(j-NUM_SPECIAL_RECORDS, false);
+						CacheLastLocate(Id, From, field, index, j);
+						success = true;
+						goto nextiter_1;
+					}
+					delete compField;
+				}
+				success = false;
+				goto nextiter_1;
+			}
+			else
+			{
+				// Index available. Using fast locate. nfetched=log2(nrecords) for first locate, 1 more fetch per locate on same criteria
+				int p;
+				if (From == FIRST_RECORD) From = NUM_SPECIAL_RECORDS;
+				else From = index->TranslateIndex(From+NUM_SPECIAL_RECORDS, i->index)+1;
+				if (From == lastLocateFrom && Id == lastLocateId && field->Contains(lastLocateFieldClone)==0 && index == lastLocateIndex && (i->index->locateUpToDate || pTable->GLocateUpToDate))
+				{
+					if (CurrentRecordIdx != lastLocateIdx) GetRecordById(lastLocateIdx-NUM_SPECIAL_RECORDS, false);
+					success = true;
+					goto nextiter_1;
+				}
+				if (From >= index->NEntries)
+				{
+					return false;
+				}
+				compField = i->index->QuickFindField(Id, i->index->Get(From));
+				cfV = /*(compField && compField->Type == FIELD_PRIVATE) ? ((PrivateField *)compField)->myField :*/ compField;
+				if (field->Contains(cfV) == 0)
+				{
+					delete compField;
+					n = i->index->TranslateIndex(From, index);
+					if (CurrentRecordIdx != n) GetRecordById(n-NUM_SPECIAL_RECORDS, false);
+					CacheLastLocate(Id, From, field, i->index, n);
+					success = true;
+					goto nextiter_1;
+				}
+				delete compField;
+				p = i->index->QuickFindEx(Id, field, From, comp_mode);
+				if (p != FIELD_NOT_FOUND)
+				{
+					n = (index->GetId() == Id) ? p : i->index->TranslateIndex(p, index);
+					if (CurrentRecordIdx != n) GetRecordById(n-NUM_SPECIAL_RECORDS, false);
+					CacheLastLocate(Id, From, field, i->index, n);
+					success = true;
+					goto nextiter_1;
+				}
+			}
+nextiter_1: // eek
+			if (success)
+			{
+				if (!MatchFilters() && !Eof())
+				{
+					From = GetRecordId();
+					if (nskip) (*nskip)++;
+				}
+				else break;
+			}
+			else break;
+		}
+
+		break;
+	case COMPARE_MODE_EXACT:
+		while (1)
+		{
+			success = false;
+			if (!i)
+			{
+				// No index for this column. Using slow locate, enumerates the database, still faster than what the user
+				// can do since we have access to QuickFindField which only read field headers
+				// in order to locate the field we have to compare. user could only read the entire record.
+				if (From == FIRST_RECORD)
+					From = NUM_SPECIAL_RECORDS;
+				else
+					From+=(NUM_SPECIAL_RECORDS+1);
+				if (From == lastLocateFrom && Id == lastLocateId && field->Compare(lastLocateFieldClone)==0 && index == lastLocateIndex && (index->locateUpToDate || pTable->GLocateUpToDate))
+				{
+					if (CurrentRecordIdx != lastLocateIdx) GetRecordById(lastLocateIdx-NUM_SPECIAL_RECORDS, false);
+					success = true;
+					goto nextiter_2;
+				}
+				for (j=From;j<index->NEntries;j++)
+				{
+					compField = index->QuickFindField(Id, index->Get(j));
+					cfV = /*(compField && compField->Type == FIELD_PRIVATE) ? ((PrivateField *)compField)->myField :*/ compField;
+					if (!field->Compare(cfV))
+					{
+						delete compField;
+						if (CurrentRecordIdx != j) GetRecordById(j-NUM_SPECIAL_RECORDS, false);
+						CacheLastLocate(Id, From, field, index, j);
+						success = true;
+						goto nextiter_2;
+					}
+					delete compField;
+				}
+				success = false;
+				goto nextiter_2;
+			}
+			else
+			{
+				// Index available. Using fast locate. nfetched=log2(nrecords) for first locate, 1 more fetch per locate on same criteria
+				int p;
+				if (From == FIRST_RECORD) From = NUM_SPECIAL_RECORDS;
+				else From = index->TranslateIndex(From+NUM_SPECIAL_RECORDS, i->index)+1;
+				if (From == lastLocateFrom && Id == lastLocateId && field->Compare(lastLocateFieldClone)==0 && index == lastLocateIndex && (i->index->locateUpToDate || pTable->GLocateUpToDate))
+				{
+					if (CurrentRecordIdx != lastLocateIdx) GetRecordById(lastLocateIdx-NUM_SPECIAL_RECORDS, false);
+					success = true;
+					goto nextiter_2;
+				}
+				if (From >= index->NEntries)
+				{
+					return false;
+				}
+				compField = i->index->QuickFindField(Id, i->index->Get(From));
+				cfV = /*(compField && compField->Type == FIELD_PRIVATE) ? ((PrivateField *)compField)->myField :*/ compField;
+				if (field->Compare(cfV) == 0)
+				{
+					if (compField)
+					{
+						delete compField;
+					}
+					n = i->index->TranslateIndex(From, index);
+					if (CurrentRecordIdx != n) GetRecordById(n-NUM_SPECIAL_RECORDS, false);
+					CacheLastLocate(Id, From, field, i->index, n);
+					success = true;
+					goto nextiter_2;
+				}
+				delete compField;
+				p = i->index->QuickFindEx(Id, field, From, comp_mode);
+				if (p != FIELD_NOT_FOUND)
+				{
+					n = (index->GetId() == Id) ? p : i->index->TranslateIndex(p, index);
+					if (CurrentRecordIdx != n) GetRecordById(n-NUM_SPECIAL_RECORDS, false);
+					CacheLastLocate(Id, From, field, i->index, n);
+					success = true;
+					goto nextiter_2;
+				}
+			}
+nextiter_2: // eek
+			if (success)
+			{
+				if (!MatchFilters() && !Eof())
+				{
+					From = GetRecordId();
+					if (nskip) (*nskip)++;
+				}
+				else break;
+			}
+			else break;
+		}
+
+		break;
+	case COMPARE_MODE_STARTS:
+		while (1)
+		{
+			success = false;
+			if (!i)
+			{
+				// No index for this column. Using slow locate, enumerates the database, still faster than what the user
+				// can do since we have access to QuickFindField which only read field headers
+				// in order to locate the field we have to compare. user could only read the entire record.
+				if (From == FIRST_RECORD)
+					From = NUM_SPECIAL_RECORDS;
+				else
+					From+=(NUM_SPECIAL_RECORDS+1);
+				if (From == lastLocateFrom && Id == lastLocateId && field->Starts(lastLocateFieldClone)==0 && index == lastLocateIndex && (index->locateUpToDate || pTable->GLocateUpToDate))
+				{
+					if (CurrentRecordIdx != lastLocateIdx) GetRecordById(lastLocateIdx-NUM_SPECIAL_RECORDS, false);
+					success = true;
+					goto nextiter_3;
+				}
+				for (j=From;j<index->NEntries;j++)
+				{
+					compField = index->QuickFindField(Id, index->Get(j));
+					cfV = /*(compField && compField->Type == FIELD_PRIVATE) ? ((PrivateField *)compField)->myField :*/ compField;
+					if (!field->Starts(cfV))
+					{
+						if (compField)
+						{
+							delete compField;
+						}
+						if (CurrentRecordIdx != j) GetRecordById(j-NUM_SPECIAL_RECORDS, false);
+						CacheLastLocate(Id, From, field, index, j);
+						success = true;
+						goto nextiter_3;
+					}
+					if (compField)
+					{
+						delete compField;
+					}
+				}
+				success = false;
+				goto nextiter_3;
+			}
+			else
+			{
+				// Index available. Using fast locate. nfetched=log2(nrecords) for first locate, 1 more fetch per locate on same criteria
+				int p;
+				if (From == FIRST_RECORD) From = NUM_SPECIAL_RECORDS;
+				else From = index->TranslateIndex(From+NUM_SPECIAL_RECORDS, i->index)+1;
+				if (From == lastLocateFrom && Id == lastLocateId && field->Starts(lastLocateFieldClone)==0 && index == lastLocateIndex && (i->index->locateUpToDate || pTable->GLocateUpToDate))
+				{
+					if (CurrentRecordIdx != lastLocateIdx) GetRecordById(lastLocateIdx-NUM_SPECIAL_RECORDS, false);
+					success = true;
+					goto nextiter_3;
+				}
+				if (From >= index->NEntries)
+				{
+					return false;
+				}
+				compField = i->index->QuickFindField(Id, i->index->Get(From));
+				cfV = /*(compField && compField->Type == FIELD_PRIVATE) ? ((PrivateField *)compField)->myField :*/ compField;
+				if (field->Starts(cfV) == 0)
+				{
+					delete compField;
+					n = i->index->TranslateIndex(From, index);
+					if (CurrentRecordIdx != n) GetRecordById(n-NUM_SPECIAL_RECORDS, false);
+					CacheLastLocate(Id, From, field, i->index, n);
+					success = true;
+					goto nextiter_3;
+				}
+				delete compField;
+				p = i->index->QuickFindEx(Id, field, From, comp_mode);
+				if (p != FIELD_NOT_FOUND)
+				{
+					n = (index->GetId() == Id) ? p : i->index->TranslateIndex(p, index);
+					if (CurrentRecordIdx != n) GetRecordById(n-NUM_SPECIAL_RECORDS, false);
+					CacheLastLocate(Id, From, field, i->index, n);
+					success = true;
+					goto nextiter_3;
+				}
+			}
+nextiter_3: // eek
+			if (success)
+			{
+				if (!MatchFilters() && !Eof())
+				{
+					From = GetRecordId();
+					if (nskip) (*nskip)++;
+				}
+				else break;
+			}
+			else break;
+		}
+
+		break;
+	}
+
+
+	return success;
+}
+
+
+//---------------------------------------------------------------------------
+void Scanner::DeleteFieldByName(const char *name)
+{
+	ColumnField *header = pTable->GetColumnByName(name);
+	if (header)
+	{
+		unsigned char Idx = header->ID;
+		DeleteFieldById(Idx);
+	}
+	return;
+}
+
+
+//---------------------------------------------------------------------------
+void Scanner::DeleteFieldById(unsigned char Id)
+{
+	Field *field = CurrentRecord->GetField(Id);
+	if (!field) return;
+	CurrentRecord->RemoveField(field);
+}
+
+//---------------------------------------------------------------------------
+void Scanner::DeleteField(Field *field)
+{
+	if (!field) return;
+	CurrentRecord->RemoveField(field);
+}
+
+
+static bool TotalSizeCalculator(Record *record, Field *f, void *context)
+{
+	size_t *totalSize = (size_t *)context;
+	*totalSize += f->GetTotalSize();
+	return true;
+}
+
+//---------------------------------------------------------------------------
+float Scanner::FragmentationLevel(void)
+{
+	int oldP = GetRecordId();
+	int i;
+	size_t totalSize=0;
+
+	if (CurrentRecord)
+	{
+		if (CurrentRecord) CurrentRecord->Release();
+		CurrentRecord = NULL;
+		CurrentRecordIdx = 0;
+	}
+
+	for (i=0;i<index->NEntries;i++)
+	{
+		Record *r = GetRecord(i);
+		if (r)
+		{
+			r->WalkFields(TotalSizeCalculator, &totalSize);
+			r->Release();
+		}
+	}
+	GetRecordById(oldP);
+	Vfseek(pTable->Handle, 0, SEEK_END);
+	return (((float)(Vftell(pTable->Handle)-strlen(__TABLE_SIGNATURE__)) / (float)totalSize) - 1) * 100;
+}
+
+//---------------------------------------------------------------------------
+int Scanner::GetRecordsCount(void)
+{
+	if (index)
+		return index->NEntries-NUM_SPECIAL_RECORDS;
+	else
+		return 0;
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::SetWorkingIndexById(unsigned char Id)
+{
+	IndexField *indx = pTable->GetIndexById(Id);
+	int v = CurrentRecordIdx;
+	if (indx)
+	{
+		if (!Eof() && !Bof())
+		{
+			IndexField *f = index->SecIndex;
+			v = index->GetCooperative(CurrentRecordIdx);
+			while (f != indx)
+			{
+				v = f->index->GetCooperative(v);
+				f = f->index->SecIndex;
+			}
+		}
+		index = indx->index;
+		CurrentRecordIdx = v;
+		GetCurrentRecord();
+	}
+	return (indx != NULL);
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::SetWorkingIndexByName(const char *desc)
+{
+	IndexField *indx = pTable->GetIndexByName(desc);
+	if (indx)
+		return SetWorkingIndexById(indx->ID);
+	else
+		return SetWorkingIndexById(-1);
+}
+
+//---------------------------------------------------------------------------
+void Scanner::IndexModified(void)
+{
+	iModified = true;
+}
+
+//---------------------------------------------------------------------------
+void Scanner::ClearDirtyBit(void)
+{
+	iModified = false;
+}
+
+//---------------------------------------------------------------------------
+Table *Scanner::GetTable(void)
+{
+	return pTable;
+}
+
+//---------------------------------------------------------------------------
+ColumnField *Scanner::GetColumnByName(const char *FieldName)
+{
+	return pTable->GetColumnByName(FieldName);
+}
+//---------------------------------------------------------------------------
+ColumnField *Scanner::GetColumnById(unsigned char Idx)
+{
+	return pTable->GetColumnById(Idx);
+}
+
+//---------------------------------------------------------------------------
+int Scanner::AddFilterByName(const char *name, Field *Data, unsigned char Op)
+{
+	ColumnField *f = pTable->GetColumnByName(name);
+	if (f)
+		return AddFilterById(f->GetFieldId(), Data, Op);
+	return ADDFILTER_FAILED;
+}
+
+//---------------------------------------------------------------------------
+int Scanner::AddFilterById(unsigned char Id, Field *Data, unsigned char Op)
+{
+	ColumnField *f = pTable->GetColumnById(Id);
+	if (f)
+	{
+		Filter *filter = new Filter(Data, f->GetFieldId(), Op);
+		FilterList.AddEntry(filter, true);
+	}
+	else
+		return ADDFILTER_FAILED;
+
+	if (in_query_parser) return 1;
+	return CheckFilters();
+}
+
+//---------------------------------------------------------------------------
+int Scanner::AddFilterOp(unsigned char Op)
+{
+	Filter *filter = new Filter(Op);
+	FilterList.AddEntry(filter, true);
+	if (in_query_parser) return 1;
+	return CheckFilters();
+}
+
+//---------------------------------------------------------------------------
+Filter *Scanner::GetLastFilter(void)
+{
+	if (FilterList.GetNElements() == 0) return NULL;
+	return (Filter *)FilterList.GetFoot();
+}
+
+//---------------------------------------------------------------------------
+void Scanner::RemoveFilters(void)
+{
+	last_query_failed = false;
+	while (FilterList.GetNElements() > 0)
+		FilterList.RemoveEntry(FilterList.GetHead());
+	FiltersOK = false;
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::CheckFilters(void)
+{
+	int f=0;
+	FiltersOK = false;
+	if (FilterList.GetNElements() == 0) // Should never happen
+		return FILTERS_INVALID;
+	Filter *filter = (Filter *)FilterList.GetHead();
+	while (filter)
+	{
+		if (f == 256) return FILTERS_INVALID;
+		int op = filter->GetOp();
+		if (filter->Data() || op == FILTER_ISEMPTY || op == FILTER_ISNOTEMPTY)
+			f++;
+		else
+		{
+			if (op != FILTER_NOT)
+				f--;
+		}
+		if (f == 0) return FILTERS_INVALID;
+		filter = (Filter *)filter->GetNext();
+	}
+
+	if (f == 1)
+	{
+		FiltersOK = true;
+		return FILTERS_COMPLETE;
+	}
+	return FILTERS_INCOMPLETE;
+}
+
+//---------------------------------------------------------------------------
+static bool EmptyMeansTrue(int op)
+{
+	return op == FILTER_ISEMPTY
+		|| op == FILTER_NOTEQUALS
+		|| op == FILTER_NOTCONTAINS;
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::MatchFilter(Filter *filter)
+{
+	Field *field = GetFieldById(filter->GetId());
+	int op = filter->GetOp();
+	Field * f = filter->Data();
+	/* old behaviour
+	if (!field)
+	return EmptyMeansTrue(op);
+	else if (op == FILTER_ISEMPTY)
+	return false;
+	else if (op == FILTER_ISNOTEMPTY)
+	return true;
+	*/
+
+	// new behaviour
+	if (!field)
+	{
+		// if field is empty and we're doing an equals op, match if f is also empty
+		if (op == FILTER_EQUALS && f) return f->ApplyFilter(f,FILTER_ISEMPTY);
+		if (op == FILTER_NOTEQUALS && f) return f->ApplyFilter(f,FILTER_ISNOTEMPTY);
+		return EmptyMeansTrue(op);
+	}
+	// no need to check for op == FILTER_ISEMPTY, the fields now handle that
+
+	return field->ApplyFilter(f, op);
+}
+
+struct Results
+{
+	void operator=(bool _val)
+	{
+		calculated=true;
+		value=_val;
+	}
+
+	bool Calc(Scanner *scanner)
+	{
+		if (!calculated)
+		{
+#if 0 /* if we want to do field-to-field comparisons */
+			Field *compare_column = filter->Data();
+			if (compare_column && compare_column->Type == FIELD_COLUMN)
+			{
+				Field *field = scanner->GetFieldById(filter->GetId());
+				Field *compare_field = scanner->GetFieldById(compare_column->ID);
+				int op = filter->GetOp();
+				value = field->ApplyFilter(compare_field, op);
+				calculated=true;
+				return value;
+			}
+#endif
+
+			value = scanner->MatchFilter(filter);
+			calculated=true;
+		}
+		return value;
+	}
+
+	void SetFilter(Filter *_filter)
+	{
+		calculated=false;
+		filter=_filter;
+	}
+private:
+	bool value;
+	bool calculated;
+	Filter *filter;
+};
+
+bool Scanner::MatchSearch(const SearchFields &fields, StringField *search_field)
+{
+	for (SearchFields::const_iterator itr = fields.begin(); itr != fields.end();itr++)
+	{
+		Field *f = GetFieldById(*itr);
+		if (f && f->Contains(search_field))
+		{
+			return true;
+		}
+	}
+	return false; // if none of the fields matched the search strings, then bail out
+}
+
+bool Scanner::MatchSearches()
+{
+	// no search means always match
+	if (search_strings.empty())
+		return true;
+
+	Scanner *s = pTable->GetDefaultScanner(); // kind of a hack but gets around private member variables
+	const SearchFields &fields = s->search_fields;
+	if (search_any)
+	{
+		for (SearchStrings::const_iterator field_itr=search_strings.begin();field_itr!=search_strings.end();field_itr++)
+		{
+			StringField *search_field = *field_itr;
+			if (MatchSearch(fields, search_field) == true)
+				return true;
+		}
+		return false; // we'll only get here if no search strings matched
+	}
+	else
+	{ // normal search (subsequent terms do further filtering
+		for (SearchStrings::const_iterator field_itr=search_strings.begin();field_itr!=search_strings.end();field_itr++)
+		{
+			StringField *search_field = *field_itr;
+			if (MatchSearch(fields, search_field) == false)
+				return false;
+		}
+		return true; // we'll only get here if all search strings have a match
+	}
+}
+
+//---------------------------------------------------------------------------
+bool Scanner::MatchFilters(void)
+{
+	if (!FiltersOK || FilterList.GetNElements() == 0)
+	{
+		//  return MatchJoins();
+		return true;
+	}
+
+	//if (!MatchSearches())
+	//return false;
+
+	ResultPtr = 0;
+
+	Results resultTable[256];
+
+	Filter *filter = (Filter *)FilterList.GetHead();
+	while (filter)
+	{
+		if (ResultPtr == 256)
+		{
+			FiltersOK = false; // Should never happen, case already discarded by CheckFilters
+			return true;
+		}
+		int op = filter->GetOp();
+		if (filter->Data() || op == FILTER_ISEMPTY || op == FILTER_ISNOTEMPTY)
+			resultTable[ResultPtr++].SetFilter(filter);
+		else
+			switch (op)
+		{
+			case FILTER_AND:
+				if (ResultPtr > 1)
+					resultTable[ResultPtr-2] = resultTable[ResultPtr-2].Calc(this) && resultTable[ResultPtr-1].Calc(this);
+				ResultPtr--;
+				break;
+			case FILTER_OR:
+				if (ResultPtr > 1)
+					resultTable[ResultPtr-2] = resultTable[ResultPtr-2].Calc(this) || resultTable[ResultPtr-1].Calc(this);
+				ResultPtr--;
+				break;
+			case FILTER_NOT:
+				if (ResultPtr > 0)
+					resultTable[ResultPtr-1] = !resultTable[ResultPtr-1].Calc(this);
+				break;
+		}
+		filter = (Filter *)filter->GetNext();
+	}
+
+	if (ResultPtr != 1) // Should never happen, case already discarded by CheckFilters
+	{
+		FiltersOK = false;
+		return true;
+	}
+
+	if (!resultTable[0].Calc(this)) return 0;
+	//  return MatchJoins();
+	//return false;
+	return MatchSearches();
+}
+
+void Scanner::WalkFilters(FilterWalker callback, void *context)
+{
+	if (callback)
+	{
+		LinkedListEntry *entry = FilterList.GetHead();
+		while (entry)
+		{
+			if (!callback(this, (Filter *)entry, context))
+				break;
+			entry = entry->Next;
+		}
+	}
+}
+
+void Scanner::Search(const char *search_string)
+{
+	// first, clear existing search terms
+	for (SearchStrings::iterator itr=search_strings.begin();itr!=search_strings.end();itr++)
+	{
+		delete *itr;
+	}
+	search_strings.clear();
+
+	if (*search_string == '*' && search_string[1] == ' ')
+	{
+		search_any=true;
+		search_string += 2;
+	}
+	else
+		search_any=false;
+
+	if (search_string)
+	{
+
+		while (*search_string)
+		{
+			while (*search_string && (*search_string == ' ' || *search_string == '\t'))
+				search_string++;
+
+			const char *end=search_string;
+
+			char c = *search_string;
+			if (c == '\"') // a quoted string
+			{
+				end++;
+				search_string++;
+				while (*end && *end != '\"')
+					end++;
+
+				if (*search_string) // make sure it's not just a quote by itself
+				{
+					if (*end == 0) // no terminating quotes
+					{
+						char *search_term = ndestring_wcsndup(search_string, end-search_string);
+						search_strings.push_back(new StringField(search_term, STRING_IS_NDESTRING));
+					}
+					else if (end > (search_string+1)) // at least one character in the quotes
+					{
+						char *search_term = ndestring_wcsndup(search_string, end-search_string-1);
+						search_strings.push_back(new StringField(search_term, STRING_IS_NDESTRING));
+						end++;
+					}
+				}
+				search_string=end;
+			}
+			else if (c)
+			{
+				while (*end && *end != ' ' && *end != '\t')
+					end++;
+
+				char *search_term = ndestring_wcsndup(search_string, end-search_string-1);
+				search_strings.push_back(new StringField(search_term, STRING_IS_NDESTRING));
+			}
+		}
+	}
+}
\ No newline at end of file