<<>>
    <<WalnutOpsMiscImpl.mesa>>
        <<Copyright Ó 1984, 1987, 1988, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Willie-Sue, June 29, 1988 4:54:23 pm PDT>>
        <<Donahue, April 10, 1986 2:49:04 pm PST>>
        <<Jack Kent, April 22, 1987 9:42:57 pm PDT  >>
        <<Doug Terry, August 30, 1990 8:25 am PDT>>
        <<>>
        <<Includes what used to be WalnutSchemaImpl, plus other stuff>>
        <<Willie-s, April 27, 1992 1:43 pm PDT>>
        <<>>
    DIRECTORY
        Atom USING [PutProp],
        BasicTime USING [GMT, nullGMT, OutOfRange],
        Convert USING [TimeFromRope],
        IO,
        LoganBerry,
        LoganBerryEntry,
        Rope USING [ROPE, Cat],
        WalnutDefs USING [LogInfo, SchemaMismatch, WalnutOpsHandle],
        WalnutOpsInternal USING [],
        WalnutRoot USING [CommitAndContinue, RootHandle, RootHandleRec],
        WalnutSchema;

    WalnutOpsMiscImpl: CEDAR PROGRAM

        IMPORTS
            Atom, BasicTime, Convert, IO, LoganBerry, LoganBerryEntry, Rope,
            WalnutDefs, WalnutRoot

        EXPORTS
            WalnutSchema, WalnutDefs

        = BEGIN OPEN WalnutSchema;
            <<>>
        <<Types>>

            GMT: TYPE = BasicTime.GMT;
            ROPE: TYPE = Rope.ROPE;

            LogInfo: TYPE = WalnutDefs.LogInfo;
            WalnutOpsHandle: TYPE = WalnutDefs.WalnutOpsHandle;

            RootHandle: TYPE = WalnutRoot.RootHandle;
            RootHandleRec: PUBLIC TYPE = WalnutRoot.RootHandleRec;
            SchemaHandle: TYPE = WalnutSchema.SchemaHandle;
            SchemaHandleRec: PUBLIC TYPE = WalnutSchema.SchemaHandleRec;

            <<>>
        <<Signals and Errors>>
            <<>>
            SchemaMismatch: PUBLIC SIGNAL[explanation: ROPE Ź NIL] = CODE;

            VersionMismatch: PUBLIC SIGNAL[explanation: ROPE Ź NIL] = CODE;

            Error: PUBLIC SIGNAL [who, code: ATOM, explanation: ROPE Ź NIL] = CODE;

        <<Variables>>
            <<>>
            completeSchemaVersionDate: GMT = Convert.TimeFromRope["June 29, 1988 12:20:00 pm PDT"];
            simpleSchemaVersionDate: GMT = Convert.TimeFromRope["June 29, 1988 4:54:19 pm PDT"];

            schemaDateField: ATOM = $SchemaDate;
            gSchemaDateInfoName: ROPE = "SchemaDInfo";


        <<Schema procedures>>

            Initialize: PUBLIC PROC [opsH: WalnutOpsHandle] RETURNS[ok: BOOL] = {

                <<initializes the database schema, and commits it to the database.>>

                sH: SchemaHandle;
                schemaDate: BasicTime.GMT = ( IF opsH.completeSchema THEN completeSchemaVersionDate ELSE simpleSchemaVersionDate );
                BEGIN 

                    schemaRelship: LoganBerry.Entry Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: gSchemaDateInfoName].entry;
                    IF schemaRelship = NIL THEN {
                        schemaRelship Ź LIST[[$Key, gSchemaDateInfoName], [schemaDateField, LoganBerryEntry.T2V[schemaDate]]];
                        LoganBerry.WriteEntry[db: opsH.db, entry: schemaRelship];
                        }
                    ELSE {
                        date: BasicTime.GMT = LoganBerryEntry.V2T[LoganBerryEntry.GetAttr[schemaRelship, schemaDateField]];
                        IF date # schemaDate THEN 
                            ERROR WalnutDefs.SchemaMismatch[TimesToRope[date, schemaDate]]
                        };

                    opsH.schemaHandle Ź sH Ź NEW[SchemaHandleRec];
                    <<>>
                    END;

                    <<the following is needed for the rest of the initialization, for type info>>
                    <<Atom.PutProp[segment, $WalnutSchemaHandle, sH];>>
                    Atom.PutProp[$WalnutLB, $WalnutSchemaHandle, sH];

                <<key values (or prefixes) for various types of entries and their associated attribute types>>
                    <<>>
                    sH.gRootInfo Ź "RootInfo";
                        sH.gRootFileStamp Ź $RootFileStamp;    --  rootFile create date for this db (gmt)
                        sH.gRootFileKey Ź $RootFileKey;    -- key from rootFile for this db (rope)
                        sH.gMailFor Ź $MailFor;        -- RName (rope)

                    sH.gLogInfo Ź "LogInfo";
                        sH.gLogFileID Ź $LogFileID;                            -- int
                        sH.gOpInProgressPos Ź $OpInProgressPos;            -- int - long running operation Pos
                        sH.gFirstDestroyedMsgPos Ź $FirstDestroyedMsgPos;    -- int
                        sH.gBytesInDestroyedMsgs Ź $BytesInDestroyedMsgs;    -- int
                        sH.gTimeOfLastScavenge Ź $TimeOfLastScavenge;    -- gmt

                    sH.gParseLogInfo Ź "ParseLogInfo";
                        sH.gParseLogInProgress Ź $ParseLogInProgress;    -- bool
                        sH.gParseLogPos Ź $ParseLogPos;        -- int

                    sH.gExpungeInfo Ź "ExpungeInfo";
                        sH.gLogExpungePhase Ź $LogExpungePhase;            -- int
                        sH.gExpungeFileID Ź $ExpungeFileID;                    -- int
                        sH.gCurrentLogPos Ź $CurrentLogPos;                    -- int
                        sH.gExpungeLogPos Ź $ExpungeLogPos;                    -- int
                        sH.gTimeOfLastExpunge Ź $TimeOfLastExpunge;        -- gmt

                    sH.gNewMailInfo Ź "NewMailInfo";
                        sH.gNewMailLogLength Ź $NewMailLogLength;        -- int
                        sH.gCopyNewMailLogPos Ź $CopyNewMailLogPos;        -- int
                        sH.gAcceptNewMailLogPos Ź $AcceptNewMailLogPos;        -- int
                        sH.gAddingServerMsgs Ź $AddingServerMsgs;        -- bool
                        sH.gLastNewMailTimeStamp Ź $LastNewMailTimeStamp;    -- time

                    sH.gReadArchiveInfo Ź "ReadArchiveInfo";
                        sH.gReadArchiveLogPos Ź $ReadArchiveLogPos;        -- int
                        sH.gCopyReadArchiveLogPos Ź $CopyReadArchiveLogPos;    -- int

                    sH.gVersionInfo Ź "VersionInfo";
                        sH.gMsgCount Ź $MsgCount;    -- int (number of msgs)
                        sH.gMsgSetCount Ź $MsgSetCount;    -- int (number of msgSets)
                        sH.gMsgSetsVersion Ź $MsgSetsVersion;    -- int (version number for msgSets)

                    sH.sBasicInfo Ź "Server-";    -- One per Server
                        sH.sBIOf Ź $ServerName;        -- Server
                        sH.sBINum Ź $Num;        -- int (number of msgs)

                    sH.msBasicInfo Ź "MsgSet-";    -- One per MsgSet
                        sH.msBIOf Ź $PrintNameIs;         -- MsgSet
                        sH.msBICount Ź $Count;         --  int (number of member msgs)
                        sH.msBIVersion Ź $Version;     --  int
                        sH.msPrintNameIs Ź $PrintNameIs;    --  rope

                    sH.mMsgInfo Ź "Msg-";    -- One per Msg
                        sH.mMIOf Ź $MsgID;             --  Msg
                        sH.mMIHerald Ź $Herald;            --  rope
                        sH.mMIShortNameLen Ź $ShortNameLen;        --  int (for icon label, etc)
                        sH.mMIEntryStart Ź $EntryStart;        --  int (start of entry in log)
                        sH.mMITextOffset Ź $TextOffset;        --  int (offset for text)
                        sH.mMITextLen Ź $TextLen;        --  int (length of text)
                        sH.mMIFormatLen Ź $FormatLen;        --  int (length of formatting)
                        sH.mMIDate Ź $Date;            --  time
                        sH.mMISubject Ź $Subject;            --  Subject (truncated to 20 chars)
                        sH.mMISubjectText Ź $SubjectText;        --  rope (up to 99 chars)
                        sH.mMIIsInReplyTo Ź $IsInReplyTo;        --  bool
                        sH.mMISender Ź $Sender;            --  Address (only one allowed)

                    sH.mDisplayInfo Ź "MsgDisplay-";    -- One per Msg
                        sH.mDIOf Ź $MsgID;             --  Msg
                        sH.mDITOCHeadEntry Ź $TOCHeadEntry;    --  rope
                        sH.mDIHasBeenRead Ź $HasBeenRead;        --  bool

                    sH.mInfo Ź "MsgShow-";    -- One per Msg
                        sH.mInfoOf Ź $InfoOf;         --  Msg
                        sH.mDateIs Ź $DateIs;        --  time
                        sH.mShowIs Ź $ShowIs;        --  Unaccepted

                    sH.cdRelation Ź "MsgCd-";    -- One per Msg 
                        sH.cdMsg Ź $Msg;         -- Msg
                        sH.cdMsgSet Ź $MsgSet;         -- MsgSet  (multiple allowed)
                        sH.cdDate Ź $DateIs;         --  time (of the Msg)

                    sH.toRelation Ź "MsgTo-";    -- One per Msg 
                        sH.toMsg Ź $Msg;         -- Msg
                        sH.toAddress Ź $Address;         -- Address  (multiple allowed)
                        sH.toDate Ź $DateIs;         --  time (of the Msg)

                    sH.ccRelation Ź "MsgCc-";    -- One per Msg 
                        sH.ccMsg Ź $Msg;         -- Msg
                        sH.ccAddress Ź $Address;         -- Address  (multiple allowed)
                        sH.ccDate Ź $DateIs;         --  time (of the Msg)

                    sH.fromRelation Ź "MsgFrom-";    -- One per Msg 
                        sH.fromMsg Ź $Msg;         -- Msg
                        sH.fromAddress Ź $Address;     -- Address  (multiple allowed)
                        sH.fromDate Ź $DateIs;         --  time (of the Msg)
                    <<>>
                <<check for relships>>
                    <<>>
                    BEGIN
                        gr: LoganBerry.Entry Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gRootInfo].entry;
                        IF gr = NIL THEN {
                            init: LoganBerry.Entry Ź LIST[
                                [$Key, sH.gRootInfo], [sH.gRootFileStamp, LoganBerryEntry.T2V[BasicTime.nullGMT]], [sH.gRootFileKey, NIL], [sH.gMailFor, NIL] ];
                            LoganBerry.WriteEntry[db: opsH.db, entry: init];

                            init Ź LIST[ [$Key, sH.gLogInfo], 
                                [sH.gLogFileID, LoganBerryEntry.I2V[0]], [sH.gOpInProgressPos, LoganBerryEntry.I2V[0]], [sH.gFirstDestroyedMsgPos, 
                                LoganBerryEntry.I2V[0]], [sH.gBytesInDestroyedMsgs, LoganBerryEntry.I2V[0]],
                                [sH.gTimeOfLastScavenge, LoganBerryEntry.T2V[BasicTime.nullGMT]] ];
                            LoganBerry.WriteEntry[db: opsH.db, entry: init];

                            init Ź LIST[ [$Key, sH.gParseLogInfo],  [sH.gParseLogInProgress, LoganBerryEntry.B2V[FALSE]], [sH.gParseLogPos, 
                            LoganBerryEntry.I2V[0]] ];
                            LoganBerry.WriteEntry[db: opsH.db, entry: init];

                            init Ź LIST[ [$Key, sH.gExpungeInfo], 
                                [sH.gLogExpungePhase, LoganBerryEntry.I2V[0]], [sH.gExpungeFileID, LoganBerryEntry.I2V[0]], [sH.gCurrentLogPos, 
                                LoganBerryEntry.I2V[0]], [sH.gExpungeLogPos, LoganBerryEntry.I2V[0]],
                                [sH.gTimeOfLastExpunge, LoganBerryEntry.T2V[BasicTime.nullGMT]]
                                ];
                            LoganBerry.WriteEntry[db: opsH.db, entry: init];

                            init Ź LIST[ [$Key, sH.gNewMailInfo], 
                                [sH.gNewMailLogLength, LoganBerryEntry.I2V[0]], [sH.gCopyNewMailLogPos, LoganBerryEntry.I2V[0]], [sH.gAcceptNewMailLogPos, 
                                LoganBerryEntry.I2V[0]],
                                [sH.gAddingServerMsgs, LoganBerryEntry.B2V[FALSE]], [sH.gLastNewMailTimeStamp, LoganBerryEntry.T2V[BasicTime.nullGMT]]
                                ];
                            LoganBerry.WriteEntry[db: opsH.db, entry: init];

                            init Ź LIST[ [$Key, sH.gReadArchiveInfo],  [sH.gReadArchiveLogPos, LoganBerryEntry.I2V[0]], [sH.gCopyReadArchiveLogPos, 
                            LoganBerryEntry.I2V[0]] ];
                            LoganBerry.WriteEntry[db: opsH.db, entry: init];

                            <<MsgCount: 0, MsgSetCount: 2, MsgSetsVersion: 1>>
                            init Ź LIST[ [$Key, sH.gVersionInfo],  [sH.gMsgCount, LoganBerryEntry.I2V[0]], [sH.gMsgSetCount, LoganBerryEntry.I2V[2]], 
                            [sH.gMsgSetsVersion, LoganBerryEntry.I2V[1]] ];
                            LoganBerry.WriteEntry[db: opsH.db, entry: init];

                            };
                        END;
                <<Commit what we've done>>
                WalnutRoot.CommitAndContinue[opsH];
                RETURN[TRUE];
                };

            SetSchemaVersion: PUBLIC PROC[opsH: WalnutOpsHandle] = {
                <<this doesn't commit, so it can be used by NewWalnutUser>>
                schemaDate: BasicTime.GMT = ( IF opsH.completeSchema THEN completeSchemaVersionDate ELSE simpleSchemaVersionDate );
                schemaRelship: LoganBerry.Entry Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: gSchemaDateInfoName].entry;
                IF schemaRelship # NIL 
                    THEN {
                        LoganBerryEntry.SetAttr[schemaRelship, schemaDateField, LoganBerryEntry.T2V[schemaDate]];
                        LoganBerry.WriteEntry[db: opsH.db, entry: schemaRelship, replace: TRUE];
                        }
                    ELSE {
                        schemaRelship Ź LIST[[$Key, gSchemaDateInfoName], [schemaDateField, LoganBerryEntry.T2V[schemaDate]]];
                        LoganBerry.WriteEntry[db: opsH.db, entry: schemaRelship];
                        };
                <<WalnutRoot.CommitAndContinue[];>>
                };

            GetSchemaVersion: PUBLIC PROC[opsH: WalnutOpsHandle]
                    RETURNS[actual, shouldBe: BasicTime.GMT] = {
                <<to be used by NewWalnutUser>>
                schemaRelship: LoganBerry.Entry Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: gSchemaDateInfoName].entry;
                shouldBe Ź ( IF opsH.completeSchema THEN completeSchemaVersionDate ELSE simpleSchemaVersionDate );
                actual Ź IF schemaRelship # NIL THEN
                    LoganBerryEntry.V2T[LoganBerryEntry.GetAttr[schemaRelship, schemaDateField]] ELSE BasicTime.nullGMT;
                };

            TimesToRope: PROC[is, shouldBe: BasicTime.GMT] RETURNS[ROPE] = {
                isR, shouldR: ROPE;
                isR Ź IO.PutFR1[NIL, [time[is]]
                    ! BasicTime.OutOfRange => {
                        isR Ź IF is = BasicTime.nullGMT THEN "nullGMT" ELSE "OutOfRange";
                        CONTINUE }];
                shouldR Ź IO.PutFR1[NIL, [time[shouldBe]]
                    ! BasicTime.OutOfRange => {
                        shouldR Ź IF shouldBe = BasicTime.nullGMT THEN "nullGMT" ELSE "OutOfRange";
                        CONTINUE }];
                RETURN[Rope.Cat["\nSchema is of: ", isR, " but should be of: ", shouldR]];
                };


        END.