

DIRECTORY
Process USING [Abort, CheckForAbort, GetCurrent, InvalidProcess],
Rope USING [Compare, Equal, ROPE],
LoganBerry,
LoganBerryEntry USING [GetAttr],
LoganQueryClass;

LoganQueryClassImpl: CEDAR PROGRAM
IMPORTS Process, Rope, LoganBerry, LoganBerryEntry
EXPORTS LoganQueryClass
~ BEGIN OPEN LoganQueryClass;

ROPE: TYPE ~ Rope.ROPE;
NextEntry: PROC [cursor: Cursor, dir: CursorDirection Ź increasing] RETURNS [entry: LoganBerry.Entry] = {
IF cursor.class.retrieve = NIL THEN RETURN[NIL];
Process.CheckForAbort[];
RETURN[cursor.class.retrieve[cursor, dir]];
};

EndGenerate: PROC [cursor: Cursor] RETURNS [] = {
IF cursor.class.destroy = NIL THEN RETURN;
cursor.class.destroy[cursor];
};
SimpleClass: QueryClass = NEW[QueryClassRec Ź [$Simple, SimpleRetrieve, SimpleDestroy]];
SimpleCursor: TYPE = REF LoganBerry.Cursor;

SimpleRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
sc: SimpleCursor => RETURN[LoganBerry.NextEntry[cursor: sc­, dir: dir]];
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Simple cursor"];
};

SimpleDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
sc: SimpleCursor => LoganBerry.EndGenerate[cursor: sc­];
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Simple cursor"];
};

GenerateEntries: PUBLIC PROC [db: LoganBerry.OpenDB, key: LoganBerry.AttributeType, start: LoganBerry.AttributeValue Ź NIL, end: LoganBerry.AttributeValue Ź NIL] RETURNS [cursor: Cursor] = {
sc: SimpleCursor Ź NEW[LoganBerry.Cursor];
sc­ Ź LoganBerry.GenerateEntries[db: db, key: key, start: start, end: end];
cursor.class Ź SimpleClass;
cursor.data Ź sc;
};
FilterClass: QueryClass = NEW[QueryClassRec Ź [$Filter, FilterRetrieve, FilterDestroy]];
FilterCursor: TYPE = REF FilterCursorRec;
FilterCursorRec: TYPE = RECORD [
input: Cursor,
pattern: ROPE,
pparsed: REF Ź NIL,
filter: MatchProc,
atype: LoganBerry.AttributeType,
stopNG: BOOLEAN Ź FALSE
];

FilterRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
fc: FilterCursor => {
match, nothingGreater: BOOLEAN Ź FALSE;
numAtypes: INT;
entry Ź NextEntry[fc.input, dir];
UNTIL match OR entry = NIL DO
numAtypes Ź 0;
FOR e: LoganBerry.Entry Ź entry, e.rest WHILE e # NIL DO
IF e.first.type = fc.atype THEN {
numAtypes Ź numAtypes + 1;
[match, nothingGreater, fc.pparsed] Ź fc.filter[e.first.value, fc.pattern, fc.pparsed];
IF match THEN EXIT;
};
ENDLOOP;
IF NOT match THEN
IF nothingGreater AND fc.stopNG AND dir = increasing AND numAtypes = 1 THEN
entry Ź NIL  -- can stop before actual end of input
ELSE
entry Ź NextEntry[fc.input, dir];
ENDLOOP;
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Filter cursor"];
};

FilterDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
fc: FilterCursor => EndGenerate[fc.input];
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Filter cursor"];
};

FilterEntries: PUBLIC PROC [input: Cursor, pattern: ROPE, filter: MatchProc, atype: LoganBerry.AttributeType, stopIfNothingGreater: BOOLEAN Ź FALSE] RETURNS [output: Cursor] = {
fc: FilterCursor Ź NEW[FilterCursorRec];
IF filter = NIL THEN
ERROR LoganBerry.Error[$BadCursor, "NIL filter proc provided"];
fc.input Ź input;
fc.pattern Ź pattern;
fc.filter Ź filter;
fc.atype Ź atype;
fc.stopNG Ź stopIfNothingGreater;
output.class Ź FilterClass;
output.data Ź fc;
};

MergerClass: QueryClass = NEW[QueryClassRec Ź [$Merger, MergerRetrieve, MergerDestroy]];
MergerCursor: TYPE = REF MergerCursorRec;
MergerCursorRec: TYPE = RECORD [
input: ARRAY [0..1] OF Cursor,
atype: LoganBerry.AttributeType,
prefetch: BOOLEAN Ź FALSE,  -- is there a prefetched entry?
prefetchEntry: LoganBerry.Entry,  -- prefetched entry if one exists
prefetchValue: LoganBerry.AttributeValue,  -- value saved for performance reasons
prefetchInput: [0..1] Ź 0,  -- which input the prefetch came from
prefetchDir: CursorDirection Ź increasing  -- direction of prefetch
];

MergerRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
mc: MergerCursor => {
newInput: [0..1];
newEntry: LoganBerry.Entry;
newValue: LoganBerry.AttributeValue;
returnNew: BOOLEAN;
IF mc.prefetch AND NOT mc.prefetchDir = dir THEN { -- prefetched in wrong direction
[] Ź NextEntry[mc.input[mc.prefetchInput], dir];
mc.prefetch Ź FALSE;
};
IF NOT mc.prefetch THEN {  -- go ahead and get an entry
mc.prefetchEntry Ź NextEntry[mc.input[0], dir];
mc.prefetchValue Ź LoganBerryEntry.GetAttr[mc.prefetchEntry, mc.atype];
mc.prefetchInput Ź 0;
mc.prefetchDir Ź dir;
mc.prefetch Ź TRUE;
};
newInput Ź ABS[1-mc.prefetchInput];
newEntry Ź NextEntry[mc.input[newInput], dir];
IF mc.prefetchEntry = NIL THEN {  -- one input already exhausted
IF newEntry = NIL THEN  -- exhausted both inputs so reset state
mc.prefetch Ź FALSE;
RETURN[newEntry];
};
IF newEntry = NIL THEN {  -- just exhausted input
entry Ź mc.prefetchEntry;
mc.prefetchEntry Ź NIL;
mc.prefetchInput Ź newInput;
RETURN[entry];
};
newValue Ź LoganBerryEntry.GetAttr[newEntry, mc.atype];
returnNew Ź SELECT Rope.Compare[newValue, mc.prefetchValue, FALSE] FROM
less => (dir = increasing),
greater => (dir = decreasing),
ENDCASE => TRUE;
IF returnNew THEN {
entry Ź newEntry;
}
ELSE {
entry Ź mc.prefetchEntry;
mc.prefetchEntry Ź newEntry;
mc.prefetchValue Ź newValue;
mc.prefetchInput Ź newInput;
};
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Merger cursor"];
};

MergerDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
mc: MergerCursor => {
EndGenerate[mc.input[0]];
EndGenerate[mc.input[1]];
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Merger cursor"];
};

MergeEntries: PUBLIC PROC [input1, input2: Cursor, atype: LoganBerry.AttributeType] RETURNS [output: Cursor] = {
mc: MergerCursor Ź NEW[MergerCursorRec];
mc.input[0] Ź input1;
mc.input[1] Ź input2;
mc.atype Ź atype;
mc.prefetch Ź FALSE;
output.class Ź MergerClass;
output.data Ź mc;
};
AntiFilterClass: QueryClass = NEW[QueryClassRec Ź [$AntiFilter, AntiFilterRetrieve, FilterDestroy]];

AntiFilterRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
fc: FilterCursor => {
match, nothingGreater: BOOLEAN Ź TRUE;
numAtypes: INT;
entry Ź NextEntry[fc.input, dir];
UNTIL NOT match OR entry = NIL DO
match Ź FALSE;
numAtypes Ź 0;
FOR e: LoganBerry.Entry Ź entry, e.rest WHILE e # NIL DO
IF e.first.type = fc.atype THEN {
numAtypes Ź numAtypes + 1;
[match, nothingGreater, fc.pparsed] Ź fc.filter[e.first.value, fc.pattern, fc.pparsed];
IF match THEN EXIT;
};
ENDLOOP;
IF match THEN
entry Ź NextEntry[fc.input, dir];
ENDLOOP;
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Filter cursor"];
};

AntiFilterEntries: PUBLIC PROC [input: Cursor, pattern: ROPE, filter: MatchProc, atype: LoganBerry.AttributeType] RETURNS [output: Cursor] = {
fc: FilterCursor Ź NEW[FilterCursorRec];
IF filter = NIL THEN
ERROR LoganBerry.Error[$BadCursor, "NIL filter proc provided"];
fc.input Ź input;
fc.pattern Ź pattern;
fc.filter Ź filter;
fc.atype Ź atype;
fc.stopNG Ź FALSE;
output.class Ź AntiFilterClass;
output.data Ź fc;
};

DuplicatorClass: QueryClass = NEW[QueryClassRec Ź [$Duplicator, DuplicatorRetrieve, DuplicatorDestroy]];
DuplicatorCursor: TYPE = REF DuplicatorCursorRec;
DuplicatorCursorRec: TYPE = RECORD [
input: Cursor,		-- input cursor
num: [0..1], 		-- which output cursor am I?
shared: SharedDuplicateData	-- stuff common to both output queues
];
SharedDuplicateData: TYPE = REF SharedDuplicateDataRec;
SharedDuplicateDataRec: TYPE = RECORD [
closed: ARRAY [0..1] OF BOOLEAN Ź ALL[FALSE],  -- cursor destroyed?
prefetched: ARRAY [0..1] OF LIST OF LoganBerry.Entry Ź ALL[NIL]  -- entries ready for output cursors
];

DuplicatorRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
dc: DuplicatorCursor => {
other: [0..1] Ź IF dc.num=0 THEN 1 ELSE 0;
IF dc.shared.prefetched[dc.num] = NIL THEN {
entry Ź NextEntry[dc.input, dir];
IF entry # NIL AND NOT dc.shared.closed[other] THEN {
IF dc.shared.prefetched[other] = NIL 
THEN {
dc.shared.prefetched[other] Ź LIST[entry];
}
ELSE {
eList: LIST OF LoganBerry.Entry Ź dc.shared.prefetched[other];
UNTIL eList.rest = NIL DO eList Ź eList.rest; ENDLOOP;
eList.rest Ź LIST[entry];
};
};
} 
ELSE {
entry Ź dc.shared.prefetched[dc.num].first;
dc.shared.prefetched[dc.num] Ź dc.shared.prefetched[dc.num].rest;
};
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Duplicator cursor"];
};

DuplicatorDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
dc: DuplicatorCursor => {
dc.shared.closed[dc.num] Ź TRUE;
IF dc.shared.closed[0] AND dc.shared.closed[1] THEN
EndGenerate[dc.input];
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Duplicator cursor"];
};

DuplicateEntries: PUBLIC PROC [input: Cursor] RETURNS [output1, output2: Cursor] = {
dc: DuplicatorCursor;
sd: SharedDuplicateData Ź NEW[SharedDuplicateDataRec];
sd.prefetched[0] Ź NIL;
sd.prefetched[1] Ź NIL;
dc Ź NEW[DuplicatorCursorRec];
dc.num Ź 0;
dc.input Ź input;
dc.shared Ź sd;
output1.class Ź DuplicatorClass;
output1.data Ź dc;
dc Ź NEW[DuplicatorCursorRec];
dc.num Ź 1;
dc.input Ź input;
dc.shared Ź sd;
output2.class Ź DuplicatorClass;
output2.data Ź dc;
};
UnDuplicatorClass: QueryClass = NEW[QueryClassRec Ź [$UnDuplicator, UnDuplicatorRetrieve, UnDuplicatorDestroy]];
UnDuplicatorCursor: TYPE = REF UnDuplicatorCursorRec;
UnDuplicatorCursorRec: TYPE = RECORD [
input: Cursor,		-- input cursor
atype: LoganBerry.AttributeType,
prev: LoganBerry.AttributeValue Ź NIL  -- previous attribute value
];

UnDuplicatorRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
udc: UnDuplicatorCursor => {
value: LoganBerry.AttributeValue;
DO -- until get new value 
entry Ź NextEntry[udc.input, dir];
value Ź LoganBerryEntry.GetAttr[entry, udc.atype];
IF entry = NIL OR NOT Rope.Equal[value, udc.prev, FALSE] THEN EXIT;
ENDLOOP;
udc.prev Ź value;
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $UnDuplicator cursor"];
};

UnDuplicatorDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
udc: UnDuplicatorCursor => EndGenerate[udc.input];
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $UnDuplicator cursor"];
};

UnDuplicateEntries: PUBLIC PROC [input: Cursor, atype: LoganBerry.AttributeType] RETURNS [output: Cursor] = {
udc: UnDuplicatorCursor Ź NEW[UnDuplicatorCursorRec];
udc.input Ź input;
udc.atype Ź atype;
output.class Ź UnDuplicatorClass;
output.data Ź udc;
};
SubtracterClass: QueryClass = NEW[QueryClassRec Ź [$Subtracter, SubtracterRetrieve, SubtracterDestroy]];
SubtracterCursor: TYPE = REF SubtracterCursorRec;
SubtracterCursorRec: TYPE = RECORD [
input: Cursor,		-- input cursor
except: Cursor,		-- exceptions
ptype: LoganBerry.AttributeType,	-- primary key
atype: LoganBerry.AttributeType,	-- attribute on which streams are ordered
avalue: LoganBerry.AttributeValue Ź NIL,  -- attribute value for current batch
exceptEntry: LoganBerry.Entry Ź NIL,	-- next entry from except cursor
exceptBatch: LIST OF LoganBerry.Entry Ź NIL,  -- more entries from except cursor
nextExceptEntry: LoganBerry.Entry Ź NIL  -- first entry from next batch on except cursor
];

NextBatch: PROC [sc: SubtracterCursor, dir: CursorDirection] RETURNS [first: LoganBerry.Entry] ~ {
sc.exceptEntry Ź sc.nextExceptEntry;
sc.nextExceptEntry Ź NIL;
sc.exceptBatch Ź NIL;
IF sc.exceptEntry = NIL THEN {
sc.exceptEntry Ź NextEntry[sc.except, dir];
IF sc.exceptEntry = NIL THEN RETURN[NIL];
};
sc.avalue Ź LoganBerryEntry.GetAttr[sc.exceptEntry, sc.atype];
sc.nextExceptEntry Ź NextEntry[sc.except, dir];
IF sc.ptype # sc.atype AND sc.nextExceptEntry # NIL THEN { -- get complete batch
tail: LIST OF LoganBerry.Entry Ź NIL;
WHILE Rope.Equal[LoganBerryEntry.GetAttr[sc.nextExceptEntry, sc.atype], sc.avalue, FALSE] DO
IF sc.exceptBatch = NIL THEN {
sc.exceptBatch Ź LIST[sc.exceptEntry];
tail Ź sc.exceptBatch;
};
tail.rest Ź LIST[sc.nextExceptEntry];
tail Ź tail.rest;
sc.nextExceptEntry Ź NextEntry[sc.except, dir];
ENDLOOP;
};
RETURN[sc.exceptEntry];
};

DiscardFromBatch: PROC [sc: SubtracterCursor, discard: LoganBerry.Entry] RETURNS [] ~ {
prev, ptr: LIST OF LoganBerry.Entry;
IF sc.exceptBatch = NIL THEN {
IF sc.exceptEntry = discard THEN sc.exceptEntry Ź NIL;
RETURN;
};
prev Ź NIL;
ptr Ź sc.exceptBatch;
WHILE ptr # NIL AND NOT ptr.first = discard DO
prev Ź ptr;
ptr Ź ptr.rest;
ENDLOOP;
IF ptr # NIL THEN {
IF prev = NIL 
THEN {
sc.exceptBatch Ź sc.exceptBatch.rest;
sc.exceptEntry Ź sc.exceptBatch.first;
} 
ELSE {
prev.rest Ź ptr.rest;
};
};
};

SubtracterRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
sc: SubtracterCursor => {
IF sc.exceptEntry = NIL THEN
sc.exceptEntry Ź NextBatch[sc, dir];
entry Ź NextEntry[sc.input, dir];
WHILE sc.exceptEntry # NIL DO  -- until get entry that should not be discarded
entryAValue: LoganBerry.AttributeValue Ź LoganBerryEntry.GetAttr[entry, sc.atype];
SELECT Rope.Compare[entryAValue, sc.avalue, FALSE] FROM
less => EXIT;  -- return entry
equal => {  -- need to check primary keys
match: LoganBerry.Entry Ź NIL;
SELECT TRUE FROM
sc.ptype = sc.atype => match Ź sc.exceptEntry;
sc.exceptBatch = NIL => {
exceptPValue, entryPValue: LoganBerry.AttributeValue;
exceptPValue Ź LoganBerryEntry.GetAttr[sc.exceptEntry, sc.ptype];
entryPValue Ź LoganBerryEntry.GetAttr[entry, sc.ptype];
IF exceptPValue = entryPValue THEN match Ź sc.exceptEntry;
};
ENDCASE => {  
entryPValue: LoganBerry.AttributeValue Ź LoganBerryEntry.GetAttr[entry, sc.ptype];
FOR eList: LIST OF LoganBerry.Entry Ź sc.exceptBatch, eList.rest WHILE eList # NIL DO
exceptPValue: LoganBerry.AttributeValue Ź LoganBerryEntry.GetAttr[eList.first, sc.ptype];
IF exceptPValue = entryPValue THEN {match Ź eList.first; EXIT};
ENDLOOP;
};
IF match = NIL THEN EXIT;  -- return entry
entry Ź NextEntry[sc.input, dir];
DiscardFromBatch[sc, match];
IF sc.exceptEntry = NIL THEN
sc.exceptEntry Ź NextBatch[sc, dir];
};
greater => {  -- discard except batch and try again
sc.exceptEntry Ź NextBatch[sc, dir];
};
ENDCASE;
ENDLOOP;
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Subtracter cursor"];
};

SubtracterDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
sc: SubtracterCursor => EndGenerate[sc.input];
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Subtracter cursor"];
};

SubtractEntries: PUBLIC PROC [input, except: Cursor, ptype, atype: LoganBerry.AttributeType] RETURNS [output: Cursor] = {
sc: SubtracterCursor Ź NEW[SubtracterCursorRec];
sc.input Ź input;
sc.except Ź except;
sc.ptype Ź ptype;
sc.atype Ź atype;
output.class Ź SubtracterClass;
output.data Ź sc;
};
FeederClass: QueryClass = NEW[QueryClassRec Ź [$Feeder, FeederRetrieve, FeederDestroy]];
FeederCursor: TYPE = REF FeederCursorRec;
FeederCursorRec: TYPE = RECORD [
input: Cursor		-- input cursor
];

FeederRetrieve: RetrieveProc = {
WITH cursor.data SELECT FROM
fc: FeederCursor => {
entry Ź NIL;
IF fc.input.class # NIL THEN 
entry Ź NextEntry[fc.input, dir];
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Feeder cursor"];
};

FeederDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
fc: FeederCursor => EndGenerate[fc.input];
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Feeder cursor"];
};

FeedEntries: PUBLIC PROC [] RETURNS [output: Cursor] = {
fc: FeederCursor Ź NEW[FeederCursorRec];
fc.input.class Ź NIL;
output.class Ź FeederClass;
output.data Ź fc;
};

SetFeederInput: PUBLIC PROC [feeder, input: Cursor] = {
WITH feeder.data SELECT FROM
fc: FeederCursor => fc.input Ź input;
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Feeder cursor"];
};
AborterClass: QueryClass = NEW[QueryClassRec Ź [$Aborter, AborterRetrieve, AborterDestroy]];
AborterCursor: TYPE = REF AborterCursorRec;
AborterCursorRec: TYPE = RECORD [
input: Cursor, 
aborted: BOOLEAN Ź FALSE,  -- if TRUE then cursor has been aborted
process: PROCESS Ź NIL  -- process currently executing retrieve operation
];

AborterRetrieve: RetrieveProc = {
ENABLE ABORTED => GOTO Aborted;
WITH cursor.data SELECT FROM
ac: AborterCursor => {
IF ac.aborted THEN GOTO Aborted;
TRUSTED {ac.process Ź LOOPHOLE[Process.GetCurrent[], PROCESS];};
entry Ź NextEntry[ac.input, dir];
ac.process Ź NIL;
};
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Aborter cursor"];
EXITS
Aborted => RETURN[NIL];
};

AborterDestroy: DestroyProc = {
WITH cursor.data SELECT FROM
ac: AborterCursor => EndGenerate[ac.input];
ENDCASE => ERROR LoganBerry.Error[$BadCursor, "Bad $Aborter cursor"];
};

EnableAborts: PUBLIC PROC [input: Cursor] RETURNS [output: Cursor] ~ {
ac: AborterCursor Ź NEW[AborterCursorRec];
ac.input Ź input;
output.class Ź AborterClass;
output.data Ź ac;
};

AbortQuery: PUBLIC PROC [cursor: Cursor] RETURNS [] ~ TRUSTED {
WITH cursor.data SELECT FROM
ac: AborterCursor => {
ac.aborted Ź TRUE;
IF ac.process # NIL THEN
Process.Abort[ac.process ! Process.InvalidProcess => CONTINUE];
};
ENDCASE => NULL;
};

END.
   $d  LoganQueryClassImpl.mesa
Copyright Ó 1985, 1992 by Xerox Corporation.  All rights reserved.
Doug Terry, July 22, 1992 2:28 pm PDT
Willie-s, April 27, 1992 11:40 am PDT
LoganQuery allows more complicated queries to be performed on a LoganBerry database than the simple retrievals provided by the LoganBerry interface.  Database queries of various classes can be registered; retrieval operations are class-specific.  For instance, the $Filter class returns database entries that match a particular pattern, while the $Merger class merges the entries returned by two independent queries.  The $Query class cascades filters to perform multiple-attribute queries.  The predefined $Simple class permits operations identical to those provided by LoganBerry.  Clients are free to create their own class of queries.

Basic operations
Retrieves the next entry relative to the given cursor.  The cursor is automatically updated so that NextEntry may be repeatedly called to enumerate entries.  NIL is returned if the cursor is at the end of the sequence and dir=increasing or at the start of the sequence and dir=decreasing.
Errors: IndexNotOpen, BadIndex, LogNotOpen, BadLogEntry
Releases the cursor; no further operations may be performed using the given cursor.  This must be called once for every cursor created.
$Simple query class

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
[cursor: Cursor] RETURNS []
Identical to the GenerateEntries operation provided by LoganBerry but returns a Cursor with class=$Simple and data=LoganBerry.Cursor.
Errors: LoganBerry.NoIndex

$Filter query class

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
could be multiple attributes of fc.atype per entry so check them all
[cursor: Cursor] RETURNS []
Returns a Cursor of class $Filter.  Retrievals using this new cursor apply the given pattern-matching filter to the appropriate attribute of entries identified by the input cursor.  A retrieval returns NIL if the input is exhausted or stopIfNothingGreater=TRUE and the filter procedure returns nothingGreater=TRUE.
$Merger query class

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
so move cursor back over prefetched entry
[cursor: Cursor] RETURNS []
Returns a Cursor of class $Merger.  Retrievals using this new cursor merge the two input streams.  The input streams should be ordered by the given attribute type.  A retrieval returns NIL only when both inputs are exhausted.
$AntiFilter query class
Shares a FilterCursor record type and the DestroyProc with the $Filter class.

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
initialize match to FALSE so will return entry if no attributes of given type
could be multiple attributes of fc.atype per entry so check them all
Returns a Cursor of class $AntiFilter.  Retrievals using this new cursor apply the given pattern-matching filter to the appropriate attribute of entries identified by the input cursor and return those entries that do NOT match the pattern.  In other words, the resulting cursor returns exactly the opposite of what would be returned by a $Filter cursor.  A retrieval returns NIL if the input is exhausted.
$Duplicator query class

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
Get entry off input queue
Add entry to other output cursor's prefetched list
Get entry off prefetched list
[cursor: Cursor] RETURNS []
Returns a pair of Cursors of class $Duplicator.  Retrievals using either new cursor return the same entries as the input cursor.  That is, each entry from the input cursor is copied to both output cursors.
$UnDuplicator query class

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
[cursor: Cursor] RETURNS []
Returns a Cursor of class $UnDuplicator.  Retrievals using the new cursor will suppress, i.e. not return, successive entries with the same value for the given attribute type.  Typically, this is used in conjunction with MergeEntries to combine two cursors and filter out duplicates; for instance UnDuplicateEntries[MergeEntries[DuplicateEntries[c]]] should produce a cursor whose output is equivalent to the orginal one.  The input stream should be ordered by the given attribute type and this attribute should be the primary key.
$Subtracter query class

Note: whenever we retrieve one entry off of the except cursor, we get all of them with the same value for atype, i.e. avalue.  This group is called a "batch".  In the common case where atype = ptype, all batches are of size one.  In this case, exceptEntry stores the single entry from the current batch.  If a batch is larger than one entry, then all of the entries for the batch are stored in the list exceptBatch; in this case, the first entry on exceptBatch is the same as the exceptEntry.  The nextExceptEntry always stores the first (and possibly only) entry from the next batch.   
Add sc.nextExceptEntry to exceptBatch list
[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
Hard case: the except stream is not ordered by primary key and contains several entries with the same secondary attribute; we compare them all to the current entry.
Discard entries from both cursors and try again
[cursor: Cursor] RETURNS []
Returns a Cursor of class $Subtracter.  Retrievals using the new cursor will return all entries from the input cursor except for those returned by the except cursor.  The input and except cursors should both be ordered by the atype attribute; ptype should indicate the primary key, which is used to determine the equivalence of two entries.
$Feeder query class

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
[cursor: Cursor] RETURNS []
Returns a Cursor of class $Feeder.  Such a cursor simply maps its input to its output.  The utility is that its input cursor can be supplied later and changed at will.
Sets (or changes) the input cursor for the feeder.
$Aborter query class

[cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: LoganBerry.Entry]
[cursor: Cursor] RETURNS []
Returns a Cursor of class $Aborter.  Operations on cursors of this class behave exactly like those on the input cursor except that they can be aborted using the AbortQuery operation defined below.
If a process is currently executing a NextEntry operation on the given cursor, the process is aborted and the operation returns NIL; any subsequent calls to NextEntry will also return NIL (i.e. the cursor is no longer useable).  This operation can only be used for cursors of class $Aborter.
Note: there are possible race conditions between AbortQuery and AborterRetrieve, but none are very bad. 
Doug Terry November 7, 1985 3:11:59 pm PST
created
changes to: DIRECTORY, ILQueryImpl, EXPORTS, ~, NextEntry, EndGenerate, SimpleRetrieve, SimpleDestroy, GenerateEntries, FilterEntries, MergeEntries, Equal, SimpleRetrieve, FilterClass, FilterCursorRec, FilterRetrieve, FilterDestroy, FilterEntries, FilterCursor, FilterCursorRec, Soundex, MergerClass, MergerRetrieve, MergerDestroy, Prefix, Wildcard, RE
Doug Terry, November 8, 1985 7:36:34 pm PST
changes to: Wildcard, SubMatch (local of Wildcard), RE, Soundex, MergerCursorRec, MergerRetrieve, DIRECTORY, IMPORTS, Equal, Prefix, NextEntry, EndGenerate, GenerateEntries, FilterEntries, MergeEntries, FilterRetrieve
Doug Terry, November 26, 1985 6:15:38 pm PST
changes to: DIRECTORY, LoganQueryImpl, IMPORTS, EXPORTS, ~, NextEntry, SimpleRetrieve, SimpleDestroy, GenerateEntries, FilterCursorRec, FilterRetrieve, FilterEntries, MergerCursorRec, MergerRetrieve, MergeEntries, GetAttributeValue, FilterDestroy, MergerDestroy
Doug Terry, December 17, 1985 11:15:09 am PST
changes to: FilterRetrieve, finderCache, RE
Doug Terry, December 23, 1985 1:58:05 pm PST
changes to: SubMatch (local of Wildcard), finderCache
Doug Terry, January 23, 1986 8:38:31 pm PST
changes to: SimpleRetrieve, SimpleDestroy, GenerateEntries
Doug Terry, February 12, 1986 11:06:34 am PST
changes to: SubMatch (local of Wildcard)
Doug Terry, April 18, 1986 5:45:39 pm PST
changes to: DIRECTORY, IMPORTS
Doug Terry, December 15, 1986 6:13:39 pm PST
NextEntry now calls Process.CheckForAbort.
changes to: DIRECTORY, IMPORTS, NextEntry
Doug Terry, April 15, 1987 11:03:13 am PDT
Moved FilterProcs to PatternMatchImpl; added $Query class from LoganBerryBrowserImpl.
changes to: QueryEntries, AnalyzeSubPlan, CheckPattern, DIRECTORY, FilterEntries, GetAttributeValue, ParseSubrange, IMPORTS, ~, FilterCursorRec, FilterRetrieve, fc (local of FilterRetrieve), MergerCursorRec, mc (local of MergerRetrieve), AbortQuery
Doug Terry, April 17, 1987 11:13:14 am PDT
Added special $Aborter class.
changes to: NextEntry, FilterCursorRec, FilterRetrieve, fc (local of FilterRetrieve), MergerCursorRec, MergerRetrieve, mc (local of MergerRetrieve), AborterClass, AborterCursor, AborterCursorRec, AborterRetrieve, ac (local of AborterRetrieve), AborterDestroy, EnableAborts, AbortQuery, ac (local of AbortQuery), ReadAttributePattern (local of ReadAttributePatterns), EntryToPatterns, ParseSubrange
Doug Terry, July 16, 1992 10:21:27 am PDT
Split off from LoganQueryImpl; added several new query classes.

Ęţ  NewlineDelimiter
(cedarcode) style codeK	Ďe6BK%K%K KţţK Ďk		K4AK"KK KK KĐbl"K+2KK KheadĎn	5iK  K77K
0KK%+KK  1KK*KKK;XK K+K Ďb KĐckUUK.HK4DKK ĄK˘K8K4DKK  [#žKKK*KKKKKK K;XK K) KK	K	KK  KKK Ą K˘UUK'KK!	KDDK%8!KKWKKK	KKĎc&3K!KKK4DKK ĄK˘K**K4DKK  LąKşK(
K:?KKKKK!KKKK K;XK K) KK  K
Ł;K"Ł!CK+Ł&QKŁ%AK+ŁCKK Ą K˘UUKKK$$K	Ł SK))K0KKŁ7K/KGKKKKK#K.Ł@Ł'?KKKŁ1KKKKKK7*GKKKKKKKKKKKK4DKK ĄK˘KKKK4DKK  ;pKáK(KKKKKKKKMMK KCdK Ą$K˘UUK&KK!		!KŁ0MKKDDK%8!KKWKKKK!KKK4DKK 
 6KK(
K:?KKKKKKKKK KGhK K1$KŁKŁ+KŁ%AKK7'KŁCKŁ#dKK Đbn$K˘UUK
* ,KK!
	5K2%K*KJ0>K6KKKKKK+KAKKK8HKK Ą"K˘K 3KKK8HKK  TKÍKK6KKKKKKK KKKKKK KKK MpK K5&KŁK  K"ŁBKK ¤&K˘UUK!!ŁK"K2K	CKKKK:JKK Ą$K˘K22K:JKK  2mKK5KKK!KKKGhK K1$KŁKŁK!Ł/K!Ł)JK$Ł$NK Ł EKŁ"PK$Ł/XKKËËK  	.bK$KKK+K
)KK>K/	ŁPK%N\K**K&KKK%KK/KKKKK  3WK$K6KKKK	.KKKK%K&KKKKKK ¤$K˘UUK$K!Ł/NKR&7KŁŁ)KK.K55KAK7K:KK¤¤KR/	UKYK?KKK		Ł*K/K!KK$KŁ%3K$KKKKK8HKK Ą"K˘K..K8HKK  AyKÔK0KKKKKKKK;XK K) KŁKK ¤ K˘UUKK!KK4DKK ĄK˘K**K4DKK  8K§K(KKKKK  7K22K%K4DKK>\K K+!KŁK	Ł'BK	Ł1IKK Ą!K˘UUK	K	 K@K!KKK5EKKK ĄK˘K++K5EKK  FKÄK*KKKKK 
 
?KŁŁKhhKK5?KKKK K*KKĎrÔŕ+KĽĽ§Ů,KĽů-KĽ+,KĽĽ5+KĽ.:-KĽ()KĽ,K*KĽ)*KUKĽĽĽř*KKĽ.Ľ%ĽDĽ.Ľ!Ľ )K?K      @Ě  z.  