[Cyan]<CedarChest6.1>Cypress>DBModelBasicImpl.mesa!1

File: DBModelBasicImpl.mesa

Contents: Implementation of basic DBView operations on entities and relships.

Last edited by:

Rick Cattell on: December 12, 1983 2:26 pm

Eric Bier on: July 16, 1982 2:38 pm

Willie-Sue on February 20, 1985 10:36:12 am PST

Table of contents

1. Data types and globals

2. Creating and destroying entities and relationships

3. Getting and setting names, properties, and attributes

4. Miscellaneous exported procedures

5. Miscellaneous support routines

DIRECTORY

Atom USING [GetPName, MakeAtom],

BasicTime,

DBStats USING [Inc, Starting, Stopping],

DBStorage,

DBTuplesConcrete,

DBEnvironment,

DB,

DBModel,

DBModelPrivate,

IO,

Rope;

DBModelBasicImpl: CEDAR PROGRAM

IMPORTS Atom, BasicTime, DBStats, DBStorage, DB, DBModel,

DBModelPrivate, IO, Rope

EXPORTS DB, -- Eq, Null, etc.

DBModel, -- "Q" procedures

DBModelPrivate, -- surrogate relship procs and GetTypeProp

DBEnvironment -- opaque types -- =

BEGIN OPEN DBTuplesConcrete, DB, DBModelPrivate, DBModel;

ROPE: TYPE = Rope.ROPE;

1. Data types and globals

Opaque type objects: exported DBTuplesConcrete => DBModel

TupleObject: PUBLIC TYPE = DBTuplesConcrete.TupleObject;

EntityObject: PUBLIC TYPE = TupleObject;

RelshipObject: PUBLIC TYPE = TupleObject;

EntitySetObject: PUBLIC TYPE = DBTuplesConcrete.EntitySetObject;

RelshipSetObject: PUBLIC TYPE = DBTuplesConcrete.RelshipSetObject;

REFS to opaque type objects

TupleHandle, TupleSet, Index, IndexFactor: TYPE = REF TupleObject;

Domain, Relation, Entity, Attribute, DataType: PUBLIC TYPE = REF EntityObject;

Relship: PUBLIC TYPE = REF RelshipObject;

SystemATuple: TYPE = REF attribute TupleObject;

SystemTSTuple: TYPE = REF tupleSet TupleObject;

SystemSTuple: TYPE = REF surrogate TupleObject;

EntitySet: PUBLIC TYPE = REF EntitySetObject;

RelshipSet: PUBLIC TYPE = REF RelshipSetObject;

fakeTransAbort: BOOL← FALSE;

2. Creating and destroying entities and relationships

QDeclareEntity: PUBLIC PROC[d: Domain, name: ROPE← NIL, version: Version← NewOrOld]

RETURNS [e: Entity] =

BEGIN

GenSym: PROC[d: Domain] RETURNS[e: Entity] =

BEGIN -- generates a unique anonymous entity

ENABLE Error => TRUSTED {IF code=NonUniqueEntityName THEN RETRY};

random: LONG CARDINAL ← LOOPHOLE[BasicTime.GetClockPulses[]];

name: ROPE ← IO.PutR[IO.card[random]];

e ← QCreateEntity[d, name];

END;

CheckDomain[d];

IF IsSystem[d] THEN ERROR Error[IllegalDomain];

IF name = NIL THEN -- Automatically generate new name/entity if no name given

IF version=OldOnly THEN RETURN[NIL] ELSE {e ← GenSym[d]; RETURN};

e ← QFetchEntity[d, name];

IF e = NIL THEN

IF version#OldOnly THEN e← QCreateEntity[d, name] ELSE NULL

ELSE -- e#NIL

IF version=NewOnly THEN ERROR Error[AlreadyExists] ELSE RETURN;

END;

QFetchEntity: PUBLIC PROC[d: Domain, name: ROPE, segment: Segment← NIL]

RETURNS [e: Entity] =

Checks to see if the entity already exists. If so, it returns it, if not, it returns NIL.

If more than one entity satisfies the constraints, it signals MultipleMatch.

Uses segment arg only for dictionary entity lookup, to know which segment to search.

Checks explicitly for lookup of the system entities.

BEGIN

nextE: Entity;

es: EntitySet;

IF fakeTransAbort THEN ERROR Aborted[QGetSegmentInfo[QSegmentOf[d]].trans];

IF d=DomainDomain THEN

SELECT TRUE FROM

name.Equal["Domain", FALSE] => RETURN[DomainDomain];

name.Equal["Relation", FALSE] => RETURN[RelationDomain];

name.Equal["Attribute", FALSE] => RETURN[AttributeDomain];

name.Equal["DataType", FALSE] => RETURN[DataTypeDomain];

name.Equal["Index", FALSE] => RETURN[IndexDomain];

name.Equal["IndexFactor", FALSE] => RETURN[IndexFactorDomain];

ENDCASE => NULL

ELSE IF d=DataTypeDomain THEN

SELECT TRUE FROM

name.Equal["RopeType", FALSE] => RETURN[RopeType];

name.Equal["IntType", FALSE] => RETURN[IntType];

name.Equal["TimeType", FALSE] => RETURN[TimeType];

name.Equal["BoolType", FALSE] => RETURN[BoolType];

ENDCASE => NULL;

es← QDomainSubset[d, name,,,, segment];

e← QNextEntity[es];

nextE← QNextEntity[es];

QReleaseEntitySet[es];

IF Null[e] THEN RETURN[NIL];

IF NOT Null[nextE] THEN ERROR Error[MultipleMatch];

RETURN[e]

END;

QCreateEntity: PUBLIC PROC [d: Domain, name: ROPE] RETURNS [e: Entity] =

Creates a new entity in d. The domain d must be a client-defined (dictionary). Enters

the entity in d's name index.

BEGIN

DBStats.Inc[CreateEntity];

CheckNullified[d];

IF IsSystem[d] THEN ERROR Error[DictionaryUpdate];

IF IsData[d] THEN ERROR Error[IllegalDomain];

e← DBStorage.CreateTuple[d];

IF name=NIL THEN

CreateEntityIndexEntries[e] -- we may disallow this name=NIL case soon

ELSE

ChangeNameBody[e: e, s: name, eD: d, existingIndexEntry: FALSE

! Error => TRUSTED {IF code=NonUniqueEntityName THEN DBStorage.DestroyTuple[e]} ];

END;

QDestroyEntity: PUBLIC PROC[e: Entity] =

Destroys a data tuple, by:

(1) deleting all references to it in indexes and groups,

(2) calling the storage level to destroy the tuple itself, its TH,

and invalidate all THs containing the same tid.

BEGIN d: Domain;

DBStats.Starting[DestroyEntity];

CheckNullified[e];

d← QDomainOf[e];

IF IsSystem[d] THEN

ERROR Error[DictionaryUpdate]

ELSE

BEGIN

DestroyLinksTo[e]; -- This also destroys any surrogate relation index entries

DestroyEntityIndexEntries[e]; -- This destroys the name index entry

SetValFromHandle[e, defaultNameHandle, RopeType, , NIL]; -- So DBStorage doesn't crash

DBStorage.DestroyTuple[e];

END;

FlushTSCache[];

DBStats.Stopping[DestroyEntity];

END;

QDeclareRelship: PUBLIC PROC[

r: Relation, init: AttributeValueList← NIL, version: Version← NewOrOld] RETURNS[t: Relship] =

Note the semantics when version=NewOnly slightly different than FetchRelship,

we want to create a new relship no matter what in this case while FetchRelship

checks to make sure it's the only one with these attribute values.

BEGIN

IF version=NewOnly OR init=NIL THEN RETURN[QCreateRelship[r, init]];

t← FetchRelship[r, init];

IF t=NIL AND version=NewOrOld THEN RETURN[QCreateRelship[r, init]];

END;

QCreateRelship: PUBLIC PROC[r: Relation, init: AttributeValueList← NIL] RETURNS[t: Relship] =

Creates a new tuple in r; r must be relation entity. Enters the new relationship

in any appropriate indexes.

BEGIN

DBStats.Inc[CreateRelship];

CheckNullified[r];

IF IsSystem[r] THEN ERROR Error[DictionaryUpdate];

CheckRelation[r];

IF V2B[SafeGetP[r, r1to1Prop]] THEN RETURN[SurrogateCreateRelship[r, init]];

t← DBStorage.CreateTuple[r];

IF init#NIL THEN SetMultipleF[t, init

! Error => TRUSTED {IF code=NonUniqueKeyValue THEN DBStorage.DestroyTuple[t]} -- clean up -- ];

CreateAllIndexEntries[t];

END;

FetchRelship: PROC[r: Relation, avl: AttributeValueList] RETURNS[t: Relship] =

r must be a system or dictionary tupleset. Implemented by calling RelationSubset

and checking for exactly one match. Raises MultipleMatch if more than one

relship returned by RelationSubset. Returns NIL if no tuples match.

BEGIN

nextRel: Relship;

rs: RelshipSet;

rs← QRelationSubset[r, avl];

t← QNextRelship[rs];

nextRel← QNextRelship[rs];

QReleaseRelshipSet[rs];

IF nextRel#NIL THEN ERROR Error[MultipleMatch]; -- need this any more?

RETURN[t]

END;

SurrogateCreateRelship: PUBLIC PROC[r: Relation, init: AttributeValueList] RETURNS[Relship] =

Note that unlike ordinary CreateRelship, we do not create any index entries; creating

a surrogate Relship just creates a surrogate referring to the actual entries, the index

entries are created or destroyed with the entity in which the data reside.

BEGIN t: SystemSTuple;

DBStats.Inc[SurrogateCreateRelship];

t← T2SST[DBStorage.ConsSystemTupleObject[surrogate]];

t.tid← SurrogateRelshipID;

t.vRelation← r;

t.vTargetAttribute← GetFirstAttribute[r];

Note that t.vEntity is not yet known!

IF init#NIL THEN SetMultipleF[t, init];

RETURN[t]

END;

QDestroyRelship: PUBLIC PROC[t: Relship] =

Destroys a (non-schema) relationship, by:

(1) destroying any index entries referencing this relationship

(2) removing it from any DBStorage groups by NILing out entity-valued fields,

(3) NILing out string-valued fields to get rid of any dangling strings created by DBStorage

(4) invalidating tupleset cache and calling the storage level to destroy the TupleHandle,

Invalidates all TupleHandles containing the same tid as a side effect of (4).

Constraints: Must destroy index entries (1) before NILing out entity refs and strings

because they are used to figure out which index entries to destroy. Steps (2) and (3)

bypass the normal creating/destroying index entries on attribute update, for efficiency.

BEGIN r: Relation← QRelationOf[t]; -- automatically does CheckRelship

IF IsSystem[r] THEN ERROR Error[DictionaryUpdate];

DBStats.Starting[DestroyRelship];

IF V2B[SafeGetP[r, r1to1Prop]] THEN

{SurrogateDestroyRelship[t]; RETURN};

DestroyAllIndexEntries[t]; -- (1)

DestroyVariableFieldsOf[t]; -- (2)

DestroyLinksFrom[t]; -- (3)

DBStorage.DestroyTuple[t]; -- (4)

FlushTSCache[];

DBStats.Stopping[DestroyRelship];

END;

SurrogateDestroyRelship: PUBLIC PROC[t: Relship] =

Puts an appropriate null value in all attributes but the first (which refs the entity in

which the others are actually stored).

BEGIN rel1: SystemSTuple← NARROW[t];

as: LIST OF Attribute;

DBStats.Inc[SurrogateDestroyRelship];

as← VL2EL[QGetPList[rel1.vRelation, aRelationOf]];

IF NOT Eq[as.first, rel1.vTargetAttribute] THEN ERROR InternalError;

as← as.rest; -- skip the target attribute

null out all other attributes of t's relship

FOR as← as, as.rest UNTIL as=NIL DO

QSetF[t, as.first, MakeNullValueOfType[GetPT[as.first, aTypeIs]]] ENDLOOP;

DestroyAllIndexEntries[t];

FlushTSCache[];

END;

3. Getting and setting names, properties, and attributes

QNameOf: PUBLIC PROC [e: Entity] RETURNS [s: ROPE] =

Works on system, dictionary, and data entities.

BEGIN

DBStats.Starting[NameOf];

CheckEntity[e];

WITH e^ SELECT FROM

e1: TupleObject[stored] =>

BEGIN eD: Domain← QDomainOf[e];

IF Eq[eD, DomainDomain] OR Eq[eD, RelationDomain] THEN -- name always second field of these:

s← V2S[GetValFromHandle[e, tupleSetNameHandle, RopeType ]]

ELSE IF Eq[eD, AttributeDomain] THEN

s← V2S[GetValFromHandle[e, attributeNameHandle, RopeType ]]

ELSE

s← V2S[GetValFromHandle[e, defaultNameHandle, RopeType ]]

END;

e1: TupleObject[tupleSet] => s← e1.vName;

e1: TupleObject[attribute] => s← e1.vName;

e1: TupleObject[entity] => s← e1.vName;

e1: TupleObject[surrogate] => ERROR Error[IllegalEntity];

ENDCASE => ERROR InternalError;

DBStats.Stopping[NameOf];

RETURN[s]

END;

QChangeName: PUBLIC PROC [e: Entity, s: ROPE] =

Works on dictionary and data entities.

BEGIN

eD: Domain;

e1: REF TupleObject[stored];

DBStats.Starting[ChangeName];

eD← QDomainOf[e];

e1 ← T2ST[e];

IF IsSystem[e] THEN -- trying to change name of one of the system entities!!

ERROR Error[DictionaryUpdate]

ELSE IF IsSystem[eD] THEN -- ChangeName is only write operation permitted on dictionary entities

DictionaryChangeName[e, s]

ELSE

ChangeNameBody[e, s, eD];

DBStats.Stopping[ChangeName];

END;

ChangeNameBody: PROC [e: Entity, s: ROPE, eD: Domain, existingIndexEntry: BOOL ← TRUE] =

Check that name is unique for this domain unless null, then set it

and make an entry in the name index for this domain.

BEGIN

IF s=NIL THEN s← "";

IF s.Length[]#0 THEN

BEGIN old: Entity← QFetchEntity[eD, s];

IF old#NIL THEN

IF Eq[old, e] THEN GOTO Return -- e already has this name

ELSE ERROR Error[NonUniqueEntityName];

END;

IF existingIndexEntry THEN DestroyEntityIndexEntries[e];

SetValFromHandle[e, defaultNameHandle, RopeType, , s];

CreateEntityIndexEntries[e];

EXITS Return => NULL

END;

DictionaryChangeName: PROC [e: Entity, s: ROPE] =

On system entities, must use special name handles according to position of name field

BEGIN

eD: Domain← QDomainOf[e];

index: DBStorage.IndexHandle;

IF Eq[eD, AttributeDomain] THEN

{SetValFromHandle[e, attributeNameHandle, RopeType, , s]; RETURN}

ELSE IF Eq[eD, DomainDomain] THEN index← GetDomainIndex[QSegmentOf[e]]

ELSE IF Eq[eD, RelationDomain] THEN index← GetRelationIndex[QSegmentOf[e]]

ELSE ERROR Error[IllegalEntity]; -- Don't know of any other system domains

Set name of domain or relation and re-enter in the index

DBStorage.DeleteFromIndex[index, ConvertToUpper[QNameOf[e]], e];

SetValFromHandle[e, tupleSetNameHandle, RopeType, , s];

DBStorage.InsertIntoIndex[index, ConvertToUpper[s], e];

END;

QGetF: PUBLIC PROC[t: Relship, a: Attribute, string: BOOL← FALSE] RETURNS[v: Value] =

Gets attribute a of t by calling the appropriate DBStorage routine.

We handle surrogate tuples as special case. GetAttributeInfo and

GetValFromHandle deal correctly with the other two cases: (1) t is dictionary

tuple, a is system tuple and (2) t is data tuple, a is dictionary tuple.

If string is TRUE, attribute is fetched as string regardless of actual type;

this is used to over-ride translation of string to entity on remote entity types.

BEGIN ENABLE InternalError => TRUSTED {IF desperate THEN GOTO GiveUp};

fh: DBStorage.FieldHandle; ft: DataType; fl: LinkType;

CheckNullified[t]; CheckNullified[a];

IF IsSurrogate[t] THEN RETURN[SurrogateGetF[t, a, string]];

DBStats.Starting[GetF];

[fh, ft, fl]← GetAttributeInfo[a, t, TRUE];

v← GetValFromHandle[t, fh, IF string THEN RopeType ELSE ft, fl];

DBStats.Stopping[GetF];

EXITS GiveUp => RETURN[NIL]

END;

QGetFS: PUBLIC PROC[t: Relship, a: Attribute] RETURNS [v: ROPE]=

BEGIN temp: Entity;

vt: DataType; vl: LinkType;

[vt, vl]← GetTypeAndLink[a];

SELECT vt FROM

RopeType =>

RETURN[V2S[QGetF[t,a]]];

IntType =>

RETURN[IO.PutR[IO.int[V2I[QGetF[t, a]]]]];

TimeType =>

RETURN[IO.PutR[IO.time[V2T[QGetF[t, a]]]]];

BoolType =>

RETURN[IF V2B[QGetF[t, a]] THEN "TRUE" ELSE "FALSE"];

RecordType => ERROR Error[NotImplemented];

ENDCASE => -- must be an entity

IF vl=Unlinked OR vl=Remote THEN

We can fetch name string directly, don't need to GetF the entity itself

RETURN[V2S[QGetF[t, a, TRUE]]]

ELSE

v← -- Fetch the entity, return null if null, prepend domain if AnyDomainType

IF Null[temp← V2E[QGetF[t, a]]] THEN ""

ELSE IF vt#AnyDomainType THEN QNameOf[temp]

ELSE Rope.Cat[QNameOf[QDomainOf[temp]], ": ", QNameOf[temp]];

END;

SafeGetF: PUBLIC PROC[t: Relship, a: Attribute] RETURNS[Value] =

Safe as GetF, but assumes its arguments are type-safe and t is not a surrogate Relship.

BEGIN

fh: DBStorage.FieldHandle; ft: DataType; fl: LinkType;

DBStats.Inc[DictionaryGetF];

[fh, ft, fl]← GetAttributeInfo[a, t, FALSE];

RETURN[GetValFromHandle[t, fh, ft, fl]];

END;

SurrogateGetF: PUBLIC PROC [t: Relship, a: Attribute, string: BOOL] RETURNS [v: Value] =

Retrieves field of surrogate tuple

BEGIN

rel1: SystemSTuple← NARROW[t];

DBStats.Starting[SurrogateGetF];

IF NOT Eq[GetPT[a, aRelationIs], rel1.vRelation] THEN ERROR Error[IllegalAttribute];

IF Eq[a, rel1.vTargetAttribute] THEN

the silly case: retrieving back the entity the relship corresponds to

v← rel1.vEntity

ELSE

normal case: must retrieve attribute of target domain instead

BEGIN fh: DBStorage.FieldHandle; ft: DataType; fl: LinkType;

[fh, ft, fl]← GetAttributeInfo[a, t]; -- fh is handle of field in the entity!

v← GetValFromHandle[rel1.vEntity, fh, IF string THEN RopeType ELSE ft, fl ];

END;

DBStats.Stopping[SurrogateGetF];

END;

QSetF: PUBLIC PROC[t: Relship, a: Attribute, v: Value, updateIndices: BOOL← TRUE] =

Call appropriate DBStorage routine according to field type.

"t" must be a data or surrogate tuple, "a" must be a dictionary tuple.

BEGIN ENABLE InternalError => TRUSTED {IF desperate THEN CONTINUE};

fh: DBStorage.FieldHandle; ft: DataType; fl: LinkType; fu: Uniqueness; fr: Relation;

CheckRelship[t];

IF IsDictionary[t] THEN ERROR Error[DictionaryUpdate];

IF IsSurrogate[t] THEN {SurrogateSetF[t, a, v]; RETURN};

[fh, ft, fl, fu, fr]← GetAttributeInfo[a, t];

IF v#NIL AND (fu=Key OR fu=OptionalKey)

AND NOT V2B[SafeGetP[fr, r1to1Prop]] THEN

check for uniqueness

BEGIN

other: Relship← FetchRelship[fr, LIST[[a, v]]];

IF other#NIL THEN ERROR Error[NonUniqueKeyValue];

END;

IF updateIndices THEN DestroyIndexEntries[t, a];

SetValFromHandle[t, fh, ft, fl, v];

IF updateIndices THEN CreateIndexEntries[t, a];

END;

SafeSetF: PUBLIC PROC[t: Relship, a: Attribute, v: Value] =

Exported to DBModelPrivate; for setting ordinary or surrogate dictionary tuple attributes.

BEGIN fh: DBStorage.FieldHandle; ft: DataType; fl: LinkType;

DBStats.Inc[DictionarySetF];

IF IsSurrogate[t] THEN SurrogateSetF[t, a, v];

[fh, ft, fl]← GetAttributeInfo[a, t];

SetValFromHandle[t, fh, ft, fl, v];

END;

QSetFS: PUBLIC PROC[t: Relship, a: Attribute, v: ROPE]=

Attempts to convert v to attribute of type required for attribute a of t.

Signals MismatchedAttributeValue if can't.

BEGIN CheckNIL[a]; QSetF[t, a, StringToValue[v, a]] END;

SurrogateSetF: PUBLIC PROC [t: Relship, a: Attribute, v: Value] =

Set field of a surrogate tuple. This may be a dictionary tuple, although only if

called through SafeSetF since QSetF (called by client) will give error in that case.

BEGIN fh: DBStorage.FieldHandle; ft: DataType; fl: LinkType;

t1: SystemSTuple← NARROW[t];

DBStats.Starting[SurrogateSetF];

[fh, ft, fl]← GetAttributeInfo[a, t];

IF Eq[a, t1.vTargetAttribute] THEN

resetting t's entity; the semantics of this are tricky

IF v#NIL AND NOT Eq[QDomainOf[V2E[v]], ft] THEN

ERROR Error[MismatchedAttributeValueType]

ELSE IF t1.vEntity#NIL THEN

ERROR Error[NotImplemented] -- Can't reset target if relation is surrogate

ELSE

t1.vEntity← V2E[v]

ELSE -- normal case, setting Nth (N>1) attribute: aHandleProp gives handle in domain

IF t1.vEntity=NIL THEN ERROR Error[MustSetKeyAttributeFirst]

ELSE

BEGIN

DestroyIndexEntries[t, a];

SetValFromHandle [t1.vEntity, fh, ft, fl, v ];

CreateIndexEntries[t, a];

END;

DBStats.Stopping[SurrogateSetF];

END;

Property operations

QGetP: PUBLIC PROC [e: Entity, aIs: Attribute, aOf: Attribute← NIL] RETURNS [v: Value] =

Find the tuple whose aOf attribute equals e and return its aIs attribute value.

Return a null value of the type of AIs if there is no such tuple.

Set aOf to be the first attribute of aIs's relation other than aIs if aOf is defaulted,

otherwise check that aOf and aIs are from the same relation and aIs is of the right type.

{RETURN[GetPBody[e, aIs, aOf, FALSE]]};

SafeGetP: PUBLIC PROC [e: Entity, aIs: Attribute] RETURNS [v: Value] =

This version of GetP is used almost everywhere within the DBModel impls.

It is faster than QGetP, as it does no type checking for some quick cases.

Works on all system, dictionary, and data entities.

Currently only checks for one quick case, a 1-to-1 surrogate attribute of a dictionary entity.

{RETURN[GetPBody[e, aIs, NIL, TRUE]]};

GetPBody: PROC [

e: Entity, aIs: Attribute, aOf: Attribute, safe: BOOL] RETURNS [v: Value] =

Used by QGetP and SafeGetP above. Assumes must do type checking if safe=FALSE.

BEGIN ENABLE InternalError => TRUSTED {IF desperate THEN GOTO GiveUp};

rs: RelshipSet; t: Relship;

IF NOT safe THEN CheckEntity[e];

IF IsSystem[e] THEN RETURN[SystemGetP[e, aIs]];

IF IsSimpleSystemAttribute[aIs] THEN

aIs is the easy attribute of a surrogate system relation, can just quick-fetch it.

RETURN[GetValFromHandle[e, T2SAT[aIs].vHandle, T2SAT[aIs].vType]];

[rs,, ]← GetPropertyRelships[e, aIs, aOf];

IF (t← QNextRelship[rs])=NIL THEN

v← MakeNullValueOfType[V2E[SafeGetP[aIs, aTypeIs]]]

ELSE

{IF QNextRelship[rs]#NIL THEN ERROR Error[MismatchedPropertyCardinality]; v← QGetF[t, aIs]};

QReleaseRelshipSet[rs];

EXITS GiveUp => RETURN[NIL];

END;

IsSimpleSystemAttribute: PROC[aIs: Attribute] RETURNS [BOOL] =

Returns TRUE if can manipulate attribute by direct fetch or store instead of using relships

Currently we only do this for system attributes.

BEGIN r: SystemTSTuple;

WITH aIs SELECT FROM

aIs1: SystemATuple =>

IF (r← T2STT[aIs1.vRelation]).vIsDomain -- invisible attr, e.g. aTypeCodeProp -- OR

r.vR1to1 AND Eq[aIs, r.vAttributes.rest.first] -- 2nd attr of surrogate, eg aRelationIs --

THEN RETURN[TRUE];

ENDCASE;

RETURN[FALSE]

END;

GetPropertyRelships: PROC[e: Entity, aIs: Attribute, aOf: Attribute]

RETURNS[rs: RelshipSet, newOf: Attribute, r: Relation] =

BEGIN

CheckAttribute[aIs];

r← V2E[SafeGetP[aIs, aRelationIs]];

IF aOf=NIL THEN

aOf← GetFirstAttribute[of: r, notCounting: aIs]

ELSE

CheckAttribute[aOf];

IF NOT CompatibleDomain[QDomainOf[e], V2E[SafeGetP[aOf, aTypeIs]]] THEN

ERROR Error[MismatchedAttributeValueType];

rs← QRelationSubset[r, LIST[[aOf, e]]];

RETURN[rs, aOf, r]

END;

GetPT: PROC [e: Entity, p: Attribute] RETURNS [Entity] =

INLINE {RETURN[ V2E[SafeGetP[e, p]] ]};

QSetP: PUBLIC PROC [

e: Entity, aIs: Attribute, v: Value, aOf: Attribute← NIL] RETURNS [t: Relship]=

Make sure arguments from client are reasonable, then do the update.

BEGIN ENABLE InternalError => TRUSTED {IF desperate THEN CONTINUE};

CheckEntity[e]; CheckAttribute[aIs];

IF IsSystem[e] OR IsSystem[aIs] THEN ERROR Error[DictionaryUpdate];

t← SafeSetP[e, aIs, v, aOf];

END;

SafeSetP: PUBLIC PROC [e: Entity, aIs: Attribute, v: Value, aOf: Attribute← NIL]

RETURNS[t: Relship] =

Same as SetP, but can check for special cases, and allows dictionary update.

Returns NIL for operations on dictionary entities (for efficiency; don't need relship)

Works on dictionary and data entities.

BEGIN rs: RelshipSet; r: Relation;

IF IsSimpleSystemAttribute[aIs] THEN

{SetValFromHandle[e, T2SAT[aIs].vHandle, T2SAT[aIs].vType, Linked, v]; RETURN};

[rs, aOf, r]← GetPropertyRelships[e, aIs, aOf];

IF IsKeyAttribute[aOf] THEN

{t← QNextRelship[rs];

IF t=NIL THEN t← QCreateRelship[r, LIST[[aOf, e], [aIs, v]]] ELSE QSetF[t, aIs, v]}

ELSE -- Don't actually need rs in this case, but foo...

t← QCreateRelship[r, LIST[[aOf, e], [aIs, v]]];

QReleaseRelshipSet[rs];

END;

QGetPList: PUBLIC PROC [e: Entity, aIs: Attribute, aOf: Attribute← NIL]

RETURNS [vl: LIST OF Value] =

BEGIN rs: RelshipSet; t: Relship;

vFirst, vLast: LIST OF Value← NIL;

CheckEntity[e];

IF IsSystem[e] THEN

{IF aIs#aUnlinkedOf AND aIs#aDomainOf THEN ERROR Error[NotImplemented]; RETURN};

[rs, aOf, ]← GetPropertyRelships[e, aIs, aOf];

IF (t← QNextRelship[rs])=NIL THEN {QReleaseRelshipSet[rs]; RETURN[NIL]};

vFirst← vLast← LIST[QGetF[t, aIs]];

FOR t← QNextRelship[rs], QNextRelship[rs] UNTIL t=NIL DO

vLast← vLast.rest← LIST[QGetF[t, aIs]] ENDLOOP;

QReleaseRelshipSet[rs];

RETURN[vFirst]

END;

QSetPList: PUBLIC PROC [e: Entity, aIs: Attribute, vl: LIST OF Value, aOf: Attribute← NIL] =

BEGIN rs: RelshipSet; r: Relation;

IF IsSystem[e] THEN ERROR Error[NotImplemented];

[rs, aOf, r]← GetPropertyRelships[e, aIs, aOf];

MErasePList[rs];

FOR vlT: LIST OF Value← vl, vlT.rest UNTIL vlT=NIL DO

[]← QCreateRelship[r, LIST[[aOf, e], [aIs, vlT.first]]] ENDLOOP;

END;

MErasePList: PROC[rs: RelshipSet] =

BEGIN

FOR t: Relship← QNextRelship[rs], QNextRelship[rs] UNTIL t=NIL DO

QDestroyRelship[t] ENDLOOP;

QReleaseRelshipSet[rs];

END;

4. Miscellaneous exported procedures

conversion routines

T2SAT: PROC[t: TupleHandle] RETURNS [SystemATuple] =

BEGIN RETURN [NARROW[t]] END;

T2STT: PROC[t: TupleHandle] RETURNS [SystemTSTuple] =

INLINE BEGIN RETURN [NARROW[t]] END;

T2SST: PROC[t: TupleHandle] RETURNS [SystemSTuple] =

INLINE BEGIN RETURN [NARROW[t]] END;

T2ST: PROC[t: TupleHandle] RETURNS [REF TupleObject[stored]] =

INLINE BEGIN RETURN [NARROW[t]] END;

must be NARROWed in the concrete context

V2R: PUBLIC SAFE PROC [v: Value] RETURNS [Relship] = CHECKED

{RETURN[NARROW[v]]};

V2E: PUBLIC SAFE PROC [v: Value] RETURNS [Entity] = CHECKED

{RETURN[NARROW[v]]};

Eq: PUBLIC SAFE PROC[e1, e2: Entity] RETURNS[BOOL] = TRUSTED

If e1 or e2 are NIL or nullified, returns TRUE iff the other is, too.

Else if e1 and e2 are in the same segment, returns TRUE iff e1 and e2 ref same entity.

Else returns FALSE.

BEGIN

IF e1=NIL THEN RETURN[Null[e2]];

IF e2=NIL THEN RETURN[Null[e1]];

IF SameSegment[e1, e2] OR IsSystem[e1] OR IsSystem[e2] THEN RETURN[e1.tid=e2.tid]

ELSE RETURN[FALSE];

END;

Null: PUBLIC SAFE PROC[t: TupleHandle] RETURNS[BOOL] = CHECKED

BEGIN RETURN[t=NIL OR t.tid=0] END;

QDomainOf: PUBLIC PROC [e: Entity] RETURNS [d: Domain] =

BEGIN

DBStats.Inc[DomainOf];

CheckNIL[e]; CheckNullified[e];

TRUSTED {

WITH e SELECT FROM

stored =>

BEGIN

ts: TupleSet← GetCachedTupleTS[e];

tsts: TupleSet;

WITH ts SELECT FROM

tupleSet =>

DomainOf[e] is a system tuple so it must be DomainDomain, RelationDomain,

or AttributeDomain: hence e is a valid entity.

RETURN[ts];

stored => {

tsts← GetCachedTupleTS[ts];

IF NOT (tsts=DomainDomain) THEN ERROR Error[IllegalEntity] ELSE RETURN [ts] };

ENDCASE => ERROR Error[IllegalEntity];

END;

tupleSet =>

SELECT e FROM

DomainDomain, RelationDomain, AttributeDomain, DataTypeDomain,

IndexDomain, IndexFactorDomain =>

RETURN[DomainDomain];

aDomain, aRelation, aType, aUniqueness, aLength, aLink, aUnlinked,

ifIndex, ifOrdinalPosition, ifAttribute, dSubType =>

RETURN[RelationDomain];

ENDCASE => ERROR Error[IllegalEntity];

attribute => RETURN[AttributeDomain];

surrogate => ERROR Error[IllegalEntity];

entity => RETURN[DataTypeDomain];

ENDCASE => ERROR;

};

END;

QRelationOf: PUBLIC PROC [t: Relship] RETURNS [r: Relation] =

BEGIN

DBStats.Inc[RelationOf];

CheckNullified[t];

TRUSTED {

WITH t SELECT FROM

stored =>

BEGIN ts: TupleSet← GetCachedTupleTS[t];

tsts: TupleSet;

WITH ts1: ts SELECT FROM

stored => {

tsts← GetCachedTupleTS[ts];

IF NOT (tsts=RelationDomain) THEN ERROR Error[IllegalRelship] ELSE RETURN [ts] };

attribute, entity, surrogate =>

ERROR Error[IllegalRelship];

tupleSet =>

IF ts1.vIsDomain THEN ERROR Error[IllegalRelship] ELSE RETURN [ts];

ENDCASE =>

ERROR Error[IllegalRelship];

END;

tupleSet, attribute, entity =>

ERROR Error[IllegalRelship];

surrogate =>

RETURN[vRelation];

ENDCASE => ERROR;

};

END;

QSegmentOf: PUBLIC PROC[x: Entity] RETURNS [Segment] = {

CheckNIL[x]; CheckNullified[x];

IF IsSystem[x] THEN ERROR Error[NotImplemented];

RETURN[DBStorage.SegmentFromTuple[x]]};

5. Miscellaneous support routines

GetValFromHandle: PUBLIC PROC [

t: TupleHandle, fh: DBStorage.FieldHandle, ft: DataType, fl: LinkType← Linked]

RETURNS [v: Value] =

All fetch operations go through this lowest level procedure. Its arguments (which give the

handle, type, and link bool) should have been fetched by a call to GetAttributeInfo.

We make a special case here for the simulated system attributes aTypeIs and aLinkIs

(See explanation in DBModelSystemImpl of these attributes).

BEGIN

SELECT ft FROM

IntType =>

IF fh = T2SAT[aLinkIs].vHandle THEN RETURN[U2V[GetTypeAndLink[t].link]]

ELSE RETURN[NEW[INT← LOOPHOLE[DBStorage.Read2Word[t, fh]] ]];

TimeType => {

time: BasicTime.GMT;

time← BasicTime.FromPupTime[DBStorage.Read2Word[t, fh]

! BasicTime.OutOfRange => {time← BasicTime.nullGMT; CONTINUE}];

RETURN[NEW[GMT← LOOPHOLE[time]]];

};

RopeType =>

RETURN [DBStorage.ReadVarByte[t, fh] ];

RecordType =>

WARNING: if we ever fetch any RecordType fields other than field handles,

the following won't do! We'll have to pass down the REF for ReadNWord.

{DBStorage.ReadNWord[t, fh, v← DBStorage.CreateFieldHandle[]]; RETURN[v] };

BoolType =>

RETURN[NEW[BOOL ← LOOPHOLE[DBStorage.Read1Word[t, fh]]]];

DataTypeDomain =>

IF fh = T2SAT[aTypeIs].vHandle THEN RETURN[GetTypeAndLink[t].type]

ELSE ERROR Error[IllegalValueType]

ENDCASE => -- ft is a domain

IF fl=Linked OR fl=Colocated THEN -- linked entity, stored as tuple ref

RETURN[DBStorage.ReadTID[t, fh]]

ELSE IF fl=Unlinked THEN -- entity name stored, look up the corresponding entity in ft

RETURN[QDeclareEntity[ft, V2S[GetValFromHandle[t, fh, RopeType]]]]

ELSE -- entity is remote, look up entity in another segment

RETURN[IDToEntity[V2S[GetValFromHandle[t, fh, RopeType]]]];

END;

SetValFromHandle: PUBLIC PROC [

t: TupleHandle, fh: DBStorage.FieldHandle, ft: DataType, fl: LinkType← Linked, v: Value] =

All store operations go through this lowest level procedure. Its arguments (which give the

handle, type, and link bool) should have been fetched by a call to GetAttributeInfo.

The aTypeIs and aLinkIs attributes must be set using SetTypeAndLink, they are illegal here.

We check that the type of v corresponds to ft of attribute at this level, and in the case

of entity-valued attributes, check that v is of the right type with CompatibleDomain.

If fl=Unlinked, then we store the name of the entity rather than the entity itself.

If fl=Remote, we store the "segment: domain: name" as string instead of entity.

fl=Colocated not yet implemented, treated just like fl=Linked.

BEGIN

WITH v SELECT FROM

v1: REF INT =>

IF ft#IntType THEN ERROR Error[MismatchedAttributeValueType]

ELSE DBStorage.Write2Word[t, fh, LOOPHOLE[v1^]];

v1: REF GMT =>

IF ft#TimeType THEN ERROR Error[MismatchedAttributeValueType]

ELSE DBStorage.Write2Word[t, fh, BasicTime.ToPupTime[v1^]];

v1: ROPE =>

IF ft#RopeType THEN ERROR Error[MismatchedAttributeValueType]

ELSE DBStorage.WriteVarByte[t, fh, v1];

v1: REF BOOL =>

IF ft#BoolType THEN ERROR Error[MismatchedAttributeValueType]

ELSE DBStorage.Write1Word[t, fh, LOOPHOLE[v1^] ];

LOOPHOLE because Write1Word expects a CARDINAL.

v1: Entity => {

IF SameSegment[v1, t] THEN

{IF NOT CompatibleDomain[QDomainOf[v1], ft] THEN

ERROR Error[MismatchedAttributeValueType]}

ELSE IF fl#Remote THEN ERROR Error[MismatchedSegment];

Type of v is OK (except we can't check this for cross-segment refs)

IF fl=Linked OR fl=Colocated THEN -- linked: store the entity reference in a group

BEGIN

temp: DBStorage.GroupScanHandle;

DBStorage.WriteTID[t, (temp← DBStorage.OpenScanGroup[v1, fh, Last])];

TID backpointer at end of group for the moment

DBStorage.CloseScanGroup[temp]

END

ELSE IF fl=Unlinked THEN -- not linked: store name as string

SetValFromHandle[t, fh, RopeType, , QNameOf[v1]]

ELSE -- fl=Remote: store segment: domain: name

SetValFromHandle[t, fh, RopeType, , EntityToID[v1]];

};

ENDCASE =>

IF v=NIL THEN -- only RopeType and Entity type allow NIL:

IF ft=RopeType THEN DBStorage.WriteVarByte[t, fh, NIL]

ELSE IF IsDomainType[ft] THEN

IF fl=Linked OR fl=Colocated THEN DBStorage.WriteTIDNil[t, fh]

ELSE DBStorage.WriteVarByte[t, fh, NIL]

ELSE -- give the guy another chance, construct a null value for him ...

SetValFromHandle[t, fh, ft, fl, MakeNullValueOfType[ft]]

ELSE -- it better be a better

IF ft#RecordType THEN ERROR Error[IllegalValue]

ELSE DBStorage.WriteNWord[t, fh, v];

END;

IDToEntity: PROC[name: ROPE] RETURNS[e: Entity] = {

Copied from Donahue's DBNamesImpl.mesa.

segNameLength: INT = Rope.Find[ name, ":" ];

domainNameLength: INT = Rope.Find[ name, ":", segNameLength+2 ] - segNameLength - 2;

segName: ROPE = Rope.Substr[ name, 0, segNameLength ];

domainName: ROPE = Rope.Substr[ name, segNameLength+2, domainNameLength ];

entityName: ROPE = Rope.Substr[ name, segNameLength+domainNameLength+4 ];

segment: DB.Segment = Atom.MakeAtom[ segName ];

domain: Domain;

domain ← DBModel.QDeclareDomain[ domainName, segment, OldOnly !

DB.Error => TRUSTED {domain ← NIL; CONTINUE} ];

e ← IF domain = NIL THEN NIL

ELSE DBModel.QFetchEntity[ domain, entityName, segment ] };

EntityToID: PROC[e: Entity] RETURNS[name: ROPE] = {

RETURN[Rope.Cat[

Atom.GetPName[DBModel.QSegmentOf[e]], ": ",

DBModel.QNameOf[DBModel.QDomainOf[e]], ": ",

DBModel.QNameOf[e] ]] };

SetMultipleF: PROC[t: Relship, alh: AttributeValueList] =

Does NOT destroy or create any existing index entries, since used only by CreateRelship

and SurrogateCreateRelship. For same reason, no type checking necessary on t.

BEGIN

FOR alhT: AttributeValueList ← alh, alhT.rest UNTIL alhT=NIL DO

QSetF[t, alhT.first.attribute, alhT.first.lo, FALSE] ENDLOOP;

END;

GetAttributeInfo: PROC[

a: Attribute, t: TupleHandle, doChecking: BOOL← TRUE] RETURNS[

handle: DBStorage.FieldHandle, type: DataType, link: LinkType,

uniqueness: Uniqueness, relation: Relation] =

Used by GetF, SetF, etc. to determine info for calling DBStorage routines. We assume

that t and a are non-NIL; we check that they are appropriately typed here: attribute a

must either be an attribute system tuple or an attribute dictionary tuple, and in both

cases it must be an attribute of the same tupleset that t comes from.

Type checking is done only if doChecking=TRUE.

BEGIN CheckNIL[a];

IF IsSystem[a] THEN

a must be attribute system tuple, and of same tupleset as t; t may be stored or surrogate.

BEGIN ts: TupleSet; a1: SystemATuple ← T2SAT[a];

DBStats.Inc[SystemGetAttributeInfo];

IF doChecking THEN {

IF t.tid=SurrogateRelshipID THEN ts← T2SST[t].vRelation ELSE ts← GetCachedTupleTS[t];

IF (a1.tid<FirstAttributeID OR NOT Eq[ts, a1.vRelation]) THEN

ERROR Error[IllegalAttribute]};

handle← a1.vHandle; type← a1.vType; link← Linked;

uniqueness← None; relation← a1.vRelation;

END

ELSE

a must be attribute dictionary tuple, and of same relation as t; t may be stored or surrogate.

BEGIN

ts: Relation;

get relation or domain of t; t may actually be an entity if a is a targetted attribute

DBStats.Inc[GetAttributeInfo];

IF t.tid=SurrogateRelshipID THEN ts← T2SST[t].vRelation

ELSE IF IsSystem[t] THEN ERROR InternalError

ELSE ts← GetCachedTupleTS[t];

retrieve attribute a's info; use cached info if already have

[relation, type, handle, uniqueness, link]← GetCachedAttributeInfo[a];

IF NOT Eq[ts, relation] THEN ERROR Error[IllegalAttribute];

END;

END.

Last edit by:

Cattell 17-Sep-81 12:00:20: Reformatted, added CompatibleDomain, lots of random additions, etc.

Cattell 29-Oct-81 20:57:39: Inline.LowHalf[QGetP[...]] ain't caught by type checking.

Cattell 23-Nov-81 12:42:26: NameElements, etc., etc.

Cattell 24-Nov-81 11:39:36: Non-binary surrogate relships.

Cattell 24-Nov-81 17:58:58: did QRelationOf[a] instead of GetPT[a, aRelation] in System*etP

Cattell 25-Nov-81 17:11:59: StringToValue has to handle vt = a Domain so that QSetFS can be used on entity-valued fields.

Cattell 26-Nov-81 14:56:11: Implemented CreateTuple on surrogate tuples, and SurrogateSetF that works on 1st attribute.

Cattell 30-Dec-81 14:17:39: Implemented QSetFS on AnyDomainType fields.

Cattell 7-Jan-82 13:30 or so: Must return a null value if FetchRelship in normal arm of QGetP fails. Added MakeNullValueOfType.

Cattell 7-Jan-82 13:31:33: Added gdfc to MakeNullValueOfType. Also: SetPVBody now checks for IllegalProperty.

Cattell 18-Jan-82 18:04:48: Auggh! Zonked by forgetting the CONTINUE in a catch phrase again. Also a

Cattell 19-Jan-82 10:23:06: QDestroyEntity didn't work. DestroyIndexEntries not used.

Cattell 21-Jan-82 9:44:13: Want to call CreateNameIndexEntry exactly once in CreateEntry, so it can't call QSetP of NameProp.

Cattell 21-Jan-82 15:03:23: StringToValue returns NIL for "" => entity conversion.

Cattell 22-Jan-82 8:45:58: DestroyLinksTo should only NIL out first attribute of tuples reffing e if they are NOT surrogate tuples. SurrogateSetF didn't work setting first attribute to NIL, either.

Cattell 3-Feb-82 10:45:27: QGetFS, QSetFS: use "" for null entity.

Cattell 3-Feb-82 10:45:27: DestroyLinksTo should actually destroy the relationships that reference e, not just NIL out the field.

Cattell 9-Mar-82 9:00:04: SetMultipleF didn't work with surrogates. DestroySurrogateRelship now sets all but first attribute to be null value of type.

Cattell April 20, 1982 8:44 am: Removed TupleSetOf, which assumed a stored tuple: most calls didn't follow this assumption anyway, use QRelationOf instead. Re-inserted DBHeapStorage.Free on de-cached attributes in FreeLastAttributesEntry (Eric Bier, what were you doing?). SurrogateSetF shouldn't be fetching field handles directly, should be doing through GetAttributeInfo. Neither should fh's be stored in Properties, will have to fix this later.

Cattell April 21, 1982 4:24 pm: It seems GetAttributeInfo can't call QRelationOf, 'cause t may be attribute entity. Also, can't cache surrogate tuple info, must explicitly check (bug caused by having SurrogateSetF go through GetAttributeInfo above).

Cattell April 23, 1982 11:59 pm: StringToValue["", IntType] now returns 0.

Cattell April 24, 1982 8:22 pm: GetTypeProp now allows DomainDomain, AttributeDomain, and RelationDomain. QSetP should already allow it. Also: SurrogateSetF checks for MustSetKeyAttributeFirst.

Cattell April 29, 1982 8:06 pm: Added DBStats.

Cattell April 29, 1982 9:29 pm: Added caching feature to TupleSetOf: it checks for lastTuplesTid. Changed a number of calls to DBStorage.ReadTupleset to use TupleSetOf instead. And for a finishing touch, added a two-tid cache, lastTuplesTid1 and lastTuplesTid2.

Cattell May 6, 1982 8:28 am: Check for ValueTypeDomain in QDomainOf.

Cattell May 6, 1982 10:26 am: ChangeName[e, foo] now works even if foo is already name of e (was generating NonUniqueEntityName).

Cattell May 22, 1982 1:16 pm: Removed caching of last two tuples tids; it wasn't a noticable performance gain. Put in some dictionary update checks. Removed TS.

Cattell May 27, 1982 11:23 am: CreateEntity needs to clean up when get NonUniqueEntityName. Similarly for CreateRelship and NonUniqueKeyValue.

Cattell June 23, 1982 10:56 am: Added capability to press on if desparate on internal errors, in order to rescue a database. Only added to main procs, for now.

Cattell June 25, 1982 10:12 am: Oops! Removed check for typeOfA=AnyDomainType in DestroyLinksFrom yesterday, thinking it wasn't necessary. But AnyDomainType is NOT a member of DomainDomain, rather it is in DataTypeDomain. I suppose it best belongs in the DomainDomain, but if I change this now various people's code will stop working so I'll wait for next major release.

Cattell July 13, 1982 1:34 pm: bug in SetF: shouldn't try to FetchRelship to check Key attributes if v is NIL.

Cattell July 16, 1982 2:38 pm: Use TRUE and FALSE instead of + and - for SetFS and GetFS on BoolType fields.

Cattell July 31, 1982 3:49 pm: GetNameIndex returns NIL if there is no name index; this happens in the DestroyEntity calls during a DestroyDomain, because the B-Tree has already been destroyed. It could also happen if we implement domains with no entity names. In either case, the DeleteFromIndex is just skipped.

Cattell August 1, 1982 12:58 pm: Added DeclareEntity and DeclareRelship, defined them in terms of GetEntityOrNil and FetchRelship in DBViewSetImpl. May be able to collapse some of these procs internally, we have many variations.

Cattell August 2, 1982 5:40 pm: Changed GetFS and SetFS (actually StringToValue) to deal specially with AnyDomainType. Such values are retrieved and stored as strings of the form "DomainName: EntityName" so that such fields can be read or written by dump/load/edit programs. SetFS still accepts strings with no ":", in which case all domains are searched.

Cattell August 24, 1982 12:13 pm: Bug in SurrogateGetF: it was calling GetP[ a, aHandleProp] instead of using GetAttributeInfo. As a result the field handle wasn't deallocated.

Cattell October 11, 1982 3:52 pm: instrumented to time critical DBView operations.

Cattell October 13, 1982 8:54 am: temp check for deleted relship in GetF.

Cattell October 19, 1982 10:20 am: Removed long-standing redundant creation and deletion of index entry in CreateEntity: it would create the tuple with a null name and then call ChangeName, which reset the index entry. Fixed by copying the code from ChangeName into CreateEntity.

Cattell November 4, 1982 4:06 pm: Changes for new properties and indices. Added new GetP, SetP, GetPList, SetPList. Added SafeGetP optimized for one case for now, and added calls to it throughout view level. Various other changes required by changes to system schema.

Cattell November 12, 1982 10:00 am: Finished updates for new indices: added DestroyAllIndexEntries, DestroyIndexEntries, CreateAllIndexEntries, CreateIndexEntries, etc., for tuples. Problem not yet fixed: when create an entity, need to create index entries for an surrogate relations on its domain. Similarly for destroy.

Cattell December 17, 1982 5:53 pm: Begin conversion to new segments, Error signal, etc. Moved many procs to PrivateImpl. Different ErrorCodes for NILArgument and NullifiedArgument. StringToValue must take attr as second arg. Eq gets more complex.

Cattell December 30, 1982 11:32 am: Added more caching: relations and tupleset info. Moved TupleSetOf to DBModelPrivate and called GetCachedTupleTS. Added aLink stuff.

Cattell on January 28, 1983 1:36 pm: CreateSurrogateRelship should have been calling GetCachedRelationInfo instead of GetFirstAttribute. Will take GetFirstAttribute out of DBModelPrivate, in fact.

Cattell & WSH on January 31, 1983 11:43 am: DestroyRelship should have called DestroyIndexEntries BEFORE calling DestroyLinksFrom and DestroyVariableFieldsOf. Odd this was never noticed before. SurrogateDestroyRelship should similarly call DestroyIndexEntries before nulling out the fields. Finally, QDestroyEntity doesn't need to call DestroyEntityIndexEntries because calling DestroyLinksTo calls SurrogateDestroyRelship on surrogates in the entity, and that destroys the index entries. CreateEntityIndexEntries, on the other hand, must be called by CreateEntity because the Relships aren't CREATED in creating an entity.

Cattell February 10, 1983 5:08 pm: QDeclareEntity[NIL name, OldOnly] should probably return NIL.

Cattell March 14, 1983 1:45 pm: moved IsDomainType to DBModelPrivateImpl.

Cattell March 17, 1983 5:57 pm: added Linked/Unlinked/Colocated/Remote link feature throughout; changed args to SetValFromHandle for this, etc.

Cattell March 25, 1983 3:31 pm: optimized creation / deletion of index entries on CreateRelship, via additional argument to QSetF so can disable index entry deletion/creation and do it once at the CreateRelship level. Statistics on Walnut showed this to be a significant portion of the time. A signficant amount of time is also being spent in the SetF in DBModelPrivateImpl.DestroyLinksFrom, which can also call QSetF w/o the index entry updates. Changed DestroyRelship to destroy index entries BEFORE NILing out string-valued and entity-valued fields. Changed the procedures that do that latter (in DBModelPrivateImpl) so that they don't try to touch index entries (using new QSetF argument).

Cattell April 15, 1983 12:27 pm: added feature that SetF[t, a, NIL] stores a null value of the appropriate type (0, FALSE, etc.)

Changed by Willie-Sue on February 15, 1985

made Cedar, added tioga formatting