-- File: DBModelPrivate.mesa
-- Contents: Internal data structures and types for Model Level modules of Cedar DB.
-- File created by Rick Cattell, September 1980
-- Last edited by:
  -- Cattell on: November 8, 1983 11:10 am 
  -- Willie-Sue on January 27, 1983 2:04 pm      

DIRECTORY
  DB,
  DBStorage,
  DBModel,
  DBTuplesConcrete,
  DBEnvironment,
  Rope;
  
DBModelPrivate: DEFINITIONS
  IMPORTS
    DB,
    DBStorage,
    Rope
  SHARES DBModel

= BEGIN OPEN DB, DBTuplesConcrete;

-- Types

ROPE: TYPE = Rope.ROPE;
TupleHandle: TYPE = REF TupleObject;
TupleObject: TYPE = DBTuplesConcrete.TupleObject;
TupleSet, Attribute, Index, IndexFactor: TYPE = TupleHandle;
Value: TYPE = REF ANY;

AttributeValueList: TYPE = LIST OF AttributeValue;
AttributeValue: TYPE = DB.AttributeValue;
AttributeList: TYPE = DB.AttributeList;


-- Global variables and constants

MaxVTID: CARDINAL = DBStorage.MaxSystemTupleID;
MaxIndexKeyLength: CARDINAL = 200;
DefaultNameLength: INT = 12;
infString, minfSting: ROPE;

desperate: BOOL; -- Set to press on in spite of internal inconsistencies

-- Counts for balancing Subset/Release calls:

entitySetCount: PUBLIC INT;
relshipSetCount: PUBLIC INT;

defaultNameHandle: DBStorage.FieldHandle;
  -- name handle used for all domains w/ default naming: always first field, 18 chars
tupleSetNameHandle: DBStorage.FieldHandle;
  -- this one is used only for tuplesets (whose handle, not name, is first field)
attributeNameHandle: DBStorage.FieldHandle;
  -- this one is used only for attributes (whose name is first field, but is system tuple)
defaultNameAttribute: Attribute;
  -- fake attribute, not really used for much


-- Private system properties and relations, used internally and not exported to DB

dHandleProp: PUBLIC Attribute;
dIndexProp: PUBLIC Attribute;
rHandleProp: PUBLIC Attribute;
r1to1Prop: PUBLIC Attribute;
aHandleProp: PUBLIC Attribute;
aTypeCodeProp: PUBLIC Attribute;
aTypeEntityProp: PUBLIC Attribute;

aDomain: PUBLIC Relation; -- used to form group of attributes targetted to domain by surrogates
  aDomainOf: PUBLIC Attribute;
  aDomainIs: PUBLIC Attribute;

aUnlinked: PUBLIC Relation; -- used to form group of attributes that reference domain w/o link
  aUnlinkedOf: PUBLIC Attribute;
  aUnlinkedIs: PUBLIC Attribute;

ifOrdinalPosition: PUBLIC Relation; -- one element per index factor
  ifOrdinalPositionOf: PUBLIC Attribute; -- the index factor
  ifOrdinalPositionIs: PUBLIC Attribute;  -- INT: ordinal position in indexing



-- Definitions of system tuple (virtual) tids

NoTID: LONG CARDINAL = 0; -- used in tuple handles nullified by storage level

DomainTSID: LONG CARDINAL = 1;
RelationTSID: LONG CARDINAL = 2;
AttributeTSID: LONG CARDINAL = 3;
DataTypeTSID: LONG CARDINAL = 4;
IndexTSID: LONG CARDINAL = 5;
IndexFactorTSID: LONG CARDINAL = 6;

aRelationTSID: LONG CARDINAL = 7;
aTypeTSID: LONG CARDINAL = 8;
aUniquenessTSID: LONG CARDINAL = 9;
aLengthTSID: LONG CARDINAL = 10;
aLinkTSID: LONG CARDINAL = 11;
aDomainTSID: LONG CARDINAL = 12;
aUnlinkedTSID: LONG CARDINAL = 13;
ifIndexTSID: LONG CARDINAL = 14;
ifOrdinalPositionTSID: LONG CARDINAL = 15;
ifAttributeTSID: LONG CARDINAL = 16;
dSubTypeTSID: LONG CARDINAL = 17;

DummyID: LONG CARDINAL = 19; -- used for one fake relation

RopeTypeID: LONG CARDINAL = 20;
IntTypeID: LONG CARDINAL = 21;
TimeTypeID: LONG CARDINAL = 22;
BoolTypeID: LONG CARDINAL = 23;
RecordTypeID: LONG CARDINAL = 24;
AnyDomainTypeID: LONG CARDINAL = 25;

SurrogateRelshipID: LONG CARDINAL = 31; -- used for surrogate relships

FirstAttributeID: LONG CARDINAL = 32; -- system attribute ids are  32, 33, ...


-- Checking procedures

IsSystem: PROC[t: TupleHandle] RETURNS[BOOL] =
  INLINE {RETURN[t.tid<=DBStorage.MaxSystemTupleID AND t.tid#SurrogateRelshipID] };

IsSurrogate: PROC[t: TupleHandle] RETURNS[BOOL] =
  INLINE {RETURN[t.tid=SurrogateRelshipID] };

IsData: PROC[t: TupleHandle] RETURNS[BOOL] =
  INLINE BEGIN
  IF t.tid<MaxVTID THEN RETURN[FALSE]; -- system tuple
  RETURN[T2CT[DBStorage.ReadTupleset[LOOPHOLE[t]]].tid>=MaxVTID];
  END;

IsDictionary: PROC[t: TupleHandle] RETURNS[BOOL] =
  INLINE BEGIN
  IF t.tid<MaxVTID THEN RETURN[FALSE];
  RETURN[T2CT[DBStorage.ReadTupleset[LOOPHOLE[t]]].tid<MaxVTID];
  END;

IsDomainType: PROC [vt: DataType] RETURNS [b: BOOL];
  -- Returns TRUE iff vt is a domain or AnyDomainType

CheckEntity: PROC [t: TupleHandle];
  -- SIGNALS if t not an Entity

CheckRelship: PROC [t: TupleHandle];
 -- SIGNALS if t not a Relship

CheckDomain: PROC [d: Domain];
  -- Is d really a domain?  SIGNAL if not.

CheckRelation: PROC [r: Relation];
  -- Is r really a relation?  SIGNAL if not.

CheckAttribute: PUBLIC PROC [a: Attribute];
  -- Is a really an attribute?  SIGNAL if not.

CheckNIL: PROC[p: REF] = INLINE {
  -- Use for ROPEs and Values only.
  IF p=NIL THEN SIGNAL DB.Error[NILArgument] };

CheckNullified: PROC [p: TupleHandle] = INLINE {
  -- Use for Entities and Relships
  IF p=NIL THEN SIGNAL DB.Error[NILArgument]
  ELSE IF p.tid=NoTID THEN SIGNAL DB.Error[NullifiedArgument] };

CompatibleType: PROC [v: Value, t: DataType, fh: DBStorage.FieldHandle_ NIL] RETURNS [BOOL];
  -- Returns TRUE if v's type is a built-in datatype identical to t or is a
  -- domain identical to t or a sub-domain of t.
  -- Takes the optional argument fh so can special-case aTypeProp.

CompatibleDomain: PUBLIC PROC [sub, super: Domain] RETURNS [BOOL];
  -- Returns TRUE iff sub=super or sub is related through transitive closure of
  -- SubType relations to super.  Should work with system sub or super.

IsKeyAttribute: PUBLIC PROC [a: Attribute] RETURNS [BOOL];

EmptyDomain: PUBLIC PROC [d: Domain] RETURNS [BOOLEAN];

EmptyRelation: PUBLIC PROC [r: Relation] RETURNS [BOOLEAN];


-- String manipulation procedures

ConvertToUpper: PUBLIC PROC[s: ROPE] RETURNS [ROPE];

StringToValue: PROC[s: ROPE, a: Attribute] RETURNS[v: Value];
  -- Converts a string to a value of the type required by a, doing the appropriate
  -- string conversion or a Fetch if dt is a Domain.

ParseSegmentName: PUBLIC PROC[path: ROPE] RETURNS [name, ext, server: ROPE];
  -- Separates [server]name.ext, and checks that name contains directory if non-local server
  
NCode: PUBLIC PROC[v: Value] RETURNS[ROPE];
  -- Converts value to encoded rope suitable for index lookup or matching.

CheckForNulls: PROC[s: ROPE] =
  INLINE BEGIN
  i: LONG CARDINAL_ 0;
  last: LONG CARDINAL_ Rope.Size[s];
  WHILE (i_ i+1) < last DO
    IF Rope.Fetch[s,i]=0C OR Rope.Fetch[s,i]=377C THEN ERROR DB.Error[IllegalString] ENDLOOP;
  END;

MakeNullValueOfType: PUBLIC PROC [vt: DataType] RETURNS[Value];


-- Caching procedures.  These are designed to essentially all accesses to the data schema once
-- a database application is in some loop; the caches must be big enough to accomplish this
-- (see DBModelPrivateImpl), with considerable performance degradation if not.

GetCachedAttributeInfo: PUBLIC PROC[x: Attribute] RETURNS[
  relation: Relation, type: DataType, handle: DBStorage.FieldHandle,
  uniqueness: Uniqueness, link: LinkType, indexFactors: LIST OF IndexFactor];
  -- Returns all info set by DeclareAttribute, and also index factors x is connected to.
  
GetCachedRelationInfo: PUBLIC PROC[
  x: Relation] RETURNS[first, second: Attribute, indexes: LIST OF Index];
  -- Returns first and second attribute of x, and also any indexes on x.
  
GetCachedDomainInfo: PUBLIC PROC [x: Domain] RETURNS [
  surrogates, indexedSurrogates: LIST OF Relation,
  nameIndex: Index, subDomains: LIST OF Domain];
  -- Returns surrogate relations targetted to x, the subset of those that are indexed,
  -- the name index for x, and the subdomains of x.

GetCachedTupleTS: PUBLIC PROC[
  x: TupleHandle] RETURNS[TupleSet];
  -- Returns domain of entity or relation of relship.
  
FlushCaches: PROC;
  -- Flushes attribute, relation, tuple caches of info.  Must do if schema changes
  -- or transaction closed or aborted.

FlushTSCache: PROC;
  -- Just flushes the tupleset cache; should be called when tuple or entity destroyed.


-- Basic and Set operations on surrogates, system tuples (exported by Basic Impl)

SurrogateGetF: PROC[t: Relship, a: Attribute, string: BOOL] RETURNS [v: Value];
  -- Called by GetF to handle the surrogate relships.  If string=TRUE then fetch as StringType
  -- regardless of actual type.
 
SurrogateSetF: PROC[t: Relship, a: Attribute, v: Value];
 -- Called by SetF to handle the surrogate relships.
 
SurrogateCreateRelship: PROC[r: Relation, init: AttributeValueList_ NIL] RETURNS[t: Relship];
  -- Creates a new surrogate relship in R, must set 1st attribute before others
   
SurrogateDestroyRelship: PROC [t: Relship];
  -- Destroys a surrogate relship (ie removes a property from an entity tuple)

SystemGetP: PROC[e: Entity, aIs: Attribute] RETURNS [v: Value];
  -- Call to handle system entities.

SafeGetP: PROC[e: Entity, aIs: Attribute] RETURNS [v: Value];
  -- Faster version of GetP which need not do type checking, for internal use only.

SafeSetP: PROC [e: Entity, aIs: Attribute, v: Value, aOf: Attribute_ NIL] RETURNS[Relship];
  -- Same as SetP but doesn't do checking and works on dictionary entities.
  -- May return NIL for dictionary entities, for efficiency (client can't call, so doesn't matter).

SafeSetF: PROC [t: Relship, a: Attribute, v: Value];
  -- Same as SetF but doesn't do checking and works on dictionary relships.

SetValFromHandle:  PROC [
  t: Relship, fh: DBStorage.FieldHandle, ft: DataType, fl: LinkType_ None, v: Value];
  -- Low level routine for actually doing field store (in BasicImpl)


-- System tuple operations (exported by System Impl)

SystemDomainSubset: PUBLIC PROC[
  d: Domain, lowName, highName: ROPE, segment: Segment] RETURNS [es: EntitySet];
  -- Call to handle system domains (RelationDomain or DomainDomain).

SystemRelationSubset: PUBLIC PROC[
  r: Relation, avl: AttributeValueList] RETURNS [rs: RelshipSet];
  -- Call to handle system relations.


-- Index- and link- related procedures (exported by Private Impl)

GetDomainIndex: PROC[s: Segment] RETURNS [Index];
  -- Returns the domain index for the segment

GetRelationIndex: PROC[s: Segment] RETURNS [Index];
  -- Returns the relation index for the segment

CreateEntityIndexEntries: PUBLIC PROC [e: Entity];
  -- Finds the name index for e's Domain and insert e into it.
  -- Also creates index entries for any surrogate relations that are actually stored in e.

DestroyEntityIndexEntries: PUBLIC PROC [e: Entity];  
  -- Find the name index for e's Domain and remove e from it.
  -- Also destroys any surrogate relation index entries.

DestroyVariableFieldsOf:  PUBLIC PROC[t: Relship];

DestroyLinksTo:  PUBLIC PROC[e: Entity];

DestroyLinksFrom:  PUBLIC PROC[t: Relship];

DestroyIndexEntries: PUBLIC PROC [t: Relship, changed: Attribute];

DestroyAllIndexEntries: PUBLIC PROC [t: Relship];

CreateIndexEntries: PUBLIC PROC [t: Relship, changed: Attribute];

CreateAllIndexEntries: PUBLIC PROC [t: Relship];

GetTypeAndLink: PUBLIC PROC [a: Attribute] RETURNS [type: Entity, link: LinkType];
  -- To get the type and link fields of an attribute, which are not stored explicitly.

SetTypeAndLink: PUBLIC PROC [a: Attribute, type: Entity, link: LinkType];
  -- To set the type and link fields of an attribute, which are not stored explicitly.


-- List and Set procedures (exported by Private Impl)

SearchEntityList: PROC [
  el: LIST OF Entity, test: PROC[Entity] RETURNS[BOOL]] RETURNS [Entity];

TransitiveClosure: PROC[e: Entity, from, to: Attribute] RETURNS [LIST OF Entity];
  -- Find all entities referenced by relships via the to attribute whose from attribute refns e,
  -- then all entities referenced by relships via the to attribute whose from
  -- attribute reference one of those, and so on, return the result as a list.

Nconc: PROC[l1, l2: LIST OF Entity] RETURNS [LIST OF Entity];
  -- Concatenates lists l1 and l2


-- Miscellaneous declarations (exported by Private Impl)

V2Rec: PROC[x: REF ANY] RETURNS [DBStorage.FieldHandle] = INLINE
  {RETURN[LOOPHOLE[x]]}; -- Can't do narrow because it's an opaque type!

T2CT: PROC[t: REF DBEnvironment.TupleObject] RETURNS [DBTuplesConcrete.TupleHandle] =
  INLINE BEGIN RETURN[LOOPHOLE[t]] END;

MakeFD: PROC [
  vt: DataType, length: INT_ 0, link: BOOL_ TRUE, a: Attribute_ NIL]
  RETURNS [DBStorage.FieldDescriptor];

systemTupleVec: REF STSVecType;
STSVecType: TYPE = ARRAY[1..MaxVTID] OF TupleHandle;
  -- passed to storage level so that proper tuple can be returned when a GetF is done and the tid is < SL.MaxSystemTupleID.

SameSegment: PROC [x, y: DBStorage.TupleHandle] RETURNS [BOOL] = INLINE
  {RETURN[DBStorage.SegmentIDFromTuple[x]=DBStorage.SegmentIDFromTuple[y]]};

TranslateToSegment: PROC[e: Entity, of: TupleHandle] RETURNS[Entity];
  -- Returns e if it is already in the same segment as "of".  Otherwise, generates error, for now.
  -- In future this proc may automatically create an entity in the to segment.

InitializeSystemTuples: PROC;
  -- System relations are documented in DB.

NumberOfAttributes: PROC [r: Relation] RETURNS [n: CARDINAL];
  -- Returns the number of attributes r has.

GetFirstAttribute: PROC [
  of: Relation, notCounting: Attribute_ NIL] RETURNS [a: Attribute];
  -- Returns the first attribute of relation "of" except for "notCounting".  Uses
  -- GetCacheRelationInfo to get attributes, unless "of" is a system relation.

FindSuperDomains: PROC[d: Domain] RETURNS [LIST OF Domain];
 -- Returns all super-Domains of d but not d itself.  Use GetCachedDomainInfo for sub-domains.


END.

Fix/extension records since 24-Nov-81:

Rick on 24-Nov-81 17:34:31: IsSurrogate[rel] returns FALSE because said tid=0 instead of SurrogateRelshipID.

Rick on 26-Nov-81 15:32:00: RopeToInt always returned an error, don't know why removed signed branch of case.

Rick on 29-Dec-81 14:47:31: Added TransitiveClosure and CompatibleType, removed TypeOf and some procs already in DBView.

Rick on April 28, 1982 9:54 am: Removed NCodeName, added NCode

Rick on May 22, 1982 6:56 pm: Added SafeSetP.  Added SetValFromHandle for DBViewGlobalImpl.

Rick on June 24, 1982 11:58 am: made FindSubDomains and FindSuperDomains non-inlines, changed FindSubDomains to work on AnyDomainType.

Rick on October 22, 1982 11:27 am: Changes for new properties and system relations.

Rick on December 19, 1982 12:58 pm: Re-organized and expanded, added DBModelPrivateImpl, new segment stuff, etc.  Added aDomain, aLink, aUnlinked, TranslateToSegment, many procedures previously in DBViewBasicImpl.

Rick on March 14, 1983 2:04 pm: expanded domain caching to include index & subdomains.