B!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !!!!!""""""""""""""""""""""""""""""""""########$$%%%%%%%%%%%%%%%%%%%%% % % % % %%%%%%&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0'1'2'3(4)5)6)7*8*9*:*;+<+=+>+?+@+A+B+C,D,E,F,G,H,I,J,K,L,M,N,O-P-Q-R-S-T-U.V.W.X.Y.Z.[.\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x/y/z/{/|0}0~0000000111111111111111111111111111111111111111111122222222222222222222222222222234445555555555555555555555555555555555555555555555555555555 5 5 5 5 5555555555666666666 6!6"6#6$6%6&6'6(7)7*7+7,7-7.7/707172737475767778797:7;7<7=7>7?7@7A7B7C7D7E7F7G7H7I7J7K7L7M7N7O7P7Q7R7S7T7U7V7W7X7Y7Z7[7\7]7^7_7`7a7b7c7d7e7f7g7h7i7j7k7l7m7n7o7p7q7r7s7t7u7v7w7x7y7z7{7|7}7~77888888888888888899999999999::::::::::::::::::::::::;;;;;<<<<<< < < < = ==Safe  Safe    Safe      Safe57Safe57None 579;AT(,4After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)-Similar to a union merge, but, on conflict, prefer the unmerged section (relvar, function, etc.) from the branch named as the argument..Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.04Dynamically create a tuple from attribute names and Ss.2Create attributes dynamically.6The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.7.no filesystem persistence/memory-only database8fsync off, not crash-safe9xfull fsync to disk (flushes kernel and physical drive buffers to ensure that the transaction is on non-volatile storage):The : structure represents a set of attribute names or the same set of names but inverted in the context of a relational expression. For example, if a relational expression has attributes named "a", "b", and "c", the < of ("a","c") is ("b").?OAn AtomFunction has a name, a type, and a function body to execute when called.K0Used in tuple creation when creating a relation.MAn atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.TThe disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.YsEvery set of modifications made to the database are atomically committed to the transaction graph as a transaction.ZBEvery transaction has context-specific information attached to it.]bThe transaction graph is the global database's state which references every committed transaction.`A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.aRestriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.jAdding an atom function should be nominally a DatabaseExpr except for the fact that it cannot be performed purely. Thus, we create the DatabaseContextIOExpr.m9Database context expressions modify the database context.Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time. I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.\Every transaction has one concrete database context and any number of isomorphic subschemas.HUsed to define a data constructor in a type constructor context such as Left a | Right bTFound in data constructors and type declarations: Left (Either Int Text) | Right Int2Metadata definition for type constructors such as data Either a b.When the changeExpr returns a different result in the database context, then the reportExpr is triggered and sent asynchronously to all clients.IA relational expression represents query (read) operations on a database.1Relation variables are identified by their names.>Used to represent the number of tuples in a relation. /A tuple is a set of attributes mapped to their  values.5The relation's tuple set is the body of the relation." represent the head of a relation.;A relation's type is composed of attribute names and types.<The AttributeName is the name of an attribute in a relation.4The AtomType uniquely identifies the type of a atom.~Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.uReturn True iff the atom type argument is relation-valued. If True, this indicates that the Atom contains a relation.*Equality function for a set of attributes. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmsrnopqtuvwxyz{|}~     mnopqrstuvwxyz{|}~jkliabcdefgh`_]^Z[\YWXVTUSMNOPQRKLJIHGFDE?@ABC:;<=>6789523401/+,-.*)(&'!"#$% t !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      NoneReturn the type of an . None None NonetCreate a new transaction which is identical to the original except that a new set of child transaction ids is added.Return the same transaction but referencing only the specific child transactions. This is useful when traversing a graph and returning a subgraph. This doesn't filter parent transactions because it assumes a head-to-root traversal.LRemove any child or parent transaction references not in the valud UUID set.1Return the singular context which is not virtual.2Returns all schemas including the concrete schema.UReturns all subschemas which are isomorphic or sub-isomorphic to the concrete schema.     None NoneNoneNoneNoneNone57h     f     h      L     NoneJ Left-biased union of attributes.-./0123456789:;<=>?@ABCDEFGHIJK-./0123456789:;<=>?@ABCDEFGHIJK-./0123456789:;<=>?@ABCDEFGHIJK-./0123456789:;<=>?@ABCDEFGHIJKNone MScan the atom types and return the resultant ConstructedAtomType or error. Used in typeFromAtomExpr to validate argument types.PUsed to determine if the atom arguments can be used with the data constructor. | This is the entry point for type-checking from RelationalExpression.hs.QFWalks the data and type constructors to extract the type variable map.RSAttempt to match the data constructor argument to a type constructor type variable.UaCreate an atom type iff all type variables are provided. Either Int Text -> ConstructedAtomType Either {Int , Text}Y See notes at Z6. The typeFromRelation must not include any wildcards.ZWhen creating a tuple, the data constructor may not complete the type constructor arguments, so the wildcard "TypeVar x" fills in the type constructor's argument. The tuple type must be resolved before it can be part of a relation, however. Example: Nothing does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.[VValidate that the type is provided with complete type variables for type constructors.]ZDetermine if two types are equal or compatible (including special handling for TypeVar x).^Determine if two typeVarLMNOPQRSTUVWXYZ[\]^_`abcLMNOPQRSTUVWXYZ[\]^_`abcLMNOPQRSTUVWXYZ[\]^_`abcLMNOPQRSTUVWXYZ[\]^_`abcNonedefgdefgdefgdefgNone hijklmnop hijklmnop hijklmnop hijklmnopNonexQConfigure a GHC environment/session which we will use for all script compilation. qrstuvwxyz{|} qrstuvwxyz{|} stuvwqrxyz{|}qrstuvwxyz{|}NoneERepresents a pointer into the database's transaction graph which the ms can then modify subsequently be committed to extend the transaction graph. The session contains staged (uncommitted) database changes as well as the means to switch between isomorphic schemas.    NoneTNoneNoneNonewCreate a junk named atom function for use with searching for an already existing function in the AtomFunctions HashSet.3AtomFunction constructor for compiled-in functions. Create a jX which can be used to load a new atom function written in Haskell and loaded at runtime.    NoneNoneNoneNoneDAn optimized form of tuple update which updates vectors efficiently. None  !None"None%&ATDifference takes two relations of the same type and returns a new relation which contains only tuples which appear in the first relation but not the second.6Return a Relation describing the types in the mapping.4Return a Relation describing the relation variables.Randomly resort the tuples. This is useful for emphasizing that two relations are equal even when they are printed to the console in different orders.""""#None$None%None                    &None+5679:;DQRT,All database values ("atoms") adhere to the ~ typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.jCreates DatabaseContextExpr necessary to load the type constructor and data constructor into the database. !"#$%&'()*+,-./ !/.-,+*)('&%$#"!  !"#$%&'()*+,-./'None1Hconvert an existing database context into its constituent expression. 012012012012(None3333)None4Create a uniqueness constraint for the attribute names and relational expression. Note that constraint can span multiple relation variables.5 Create a mY which can be used to add a uniqueness constraint to attributes on one relation variable.6^Create a foreign key constraint from the first relation variable and attributes to the second.456456456456*None789:789:789:789:+None;<=>?@A;<=>?@A;<=>?@A;<=>?@A,None CDEFGHIJKLM CDEFGHIJKLM CDEFGHIJKLM CDEFGHIJKLM-NoneOPQRSTOPQRSTOPQRSTOPQRST.None#UVWXYZ[\]^_`abcdefghijklmnopqrstuvw#UVWXYZ[\]^_`abcdefghijklmnopqrstuvw#YZ[\]^_`abcdefWXVUghijklmnopqrstuvw"UVWXYZ[\]^_`abcdefghijklmnopqrstuvw/Nonexyz{xyz{xyz{xyz{0None |}~ |}~ |}~|}~1NoneTKUsed to start a fresh database state for a new database context expression.AValidate that the type of the AtomExpr matches the expected type.3Look up the type's name and create a new attribute.+*+$2None57Return an error if the schema is not isomorphic to the base database context. A schema is fully isomorphic iff all relvars in the base context are in the "out" relvars, but only once. TODO: add relvar must appear exactly once constraintRelation variables names represented in the virtual schema space. Useful for determining if a relvar name is valid in the schema.LCheck that all mentioned relvars are actually present in the current schema.~If the database context expression adds or removes a relvar, we need to update the isomorphs to create a passthrough Isomorph.IMorph a relational expression in one schema to another isomorphic schema.Apply the isomorphism transformations to the relational expression to convert the relational expression from operating on one schema to a disparate, isomorphic schema.jCreate inclusion dependencies mainly for IsoRestrict because the predicate should hold in the base schema.3None[Returns the notifications which should be triggered based on the transition from the first  to the second .4None5None57 QOperators which manipulate a transaction graph and which transaction the current Session is based upon.7Used for git-style head backtracking such as topic~3^2.bgit equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be madeTgit equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent8Record a lookup for a specific transaction in the graph.Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graphReturns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.Search from a past graph point to all following heads for a specific transaction. If found, return the transaction path, otherwise a RelationalError.After splicing out a subgraph, run it through this function to remove references to transactions which are not in the subgraph.444%6None9;The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time). !"#$%&'  !"'&%$# !" !"#$%&'7None57RThe initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.,()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS,()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS,RSPQNOLMJKHIFGDEBC@A>?<=:;8967452301./,-*+()()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS8NoneThe incremental writer which only writes from the set of heads. New heads must be written on every commit. Most heads will already be written on every commit.None57T%4There are several reasons why a connection can fail.The d represents either local or remote access to a database. All operations flow through the connection."When a notification is fired, the ` is evaluated in the commit's context, so that is returned along with the original notification.IUsed for callbacks from the server when monitored changes have been made. Construct a  to describe how to make the a. The database can be run within the current process or running remotely via distributed-process.The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.6The empty notification callback ignores all callbacks. Create a D for use in connecting to a remote server using distributed-process.>Use this for connecting to remote servers on the default port.IUse this for connecting to remote servers with the default database name.EUse this for connecting to remote servers with the default head name.Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events. To create a ) to a remote or local database, create a  and call .GCreate a new session at the transaction id and return the session's Id.Call m with a transaction graph's head's name to create a new session pinned to that head. This function returns a [ which can be used in other function calls to reference the point in the transaction graph.tUsed internally for server connections to keep track of remote nodes for the purpose of sending notifications later.ODiscards a session, eliminating any uncommitted changes present in the session.J cleans up the database access connection and closes any relevant sockets.=Returns the name of the currently selected isomorphic schema.&Switch to the named isomorphic schema.Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.[Execute a database context IO-monad-based expression for the given session and connection. js modify the DatabaseContext but cannot be purely implemented. this is almost completely identical to executeDatabaseContextExpr aboveExecute a transaction graph expression in the context of the session and connection. Transaction graph operators modify the transaction graph state.dA trans-graph expression is a relational query executed against the entirety of a transaction graph.ESchema expressions manipulate the isomorphic schemas for the current .After modifying a ,  the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.(Discard any changes made in the current  and . This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.oWrite the transaction graph to disk. This function can be used to incrementally write new transactions to disk.Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types. Return a MapL of the database's constraints at the context of the session and connection.Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.Return a relation which represents the current state of the global transaction graph. The attributes are * current- boolean attribute representing whether or not the current session references this transaction * head- text attribute which is a non-empty ` iff the transaction references a head. * id- id attribute of the transaction * parents- a relation-valued attribute which contains a relation of transaction ids which are parent transaction to the transactionEReturns the names and types of the relation variables in the current .hReturns the transaction id for the connection's disconnected transaction committed parent transaction. YReturns Just the name of the head of the current disconnected transaction or Nothing. .Returns a listing of all available atom types.f !"#$%&'()*+,-./0123456789:;<0123456789:;<=>MNOPQR`abcdefghjklmsrnopqtuvwxyz{|}~0456`6789mnopqrstuvwxyz{|}~jkl05456234:;<=>01MNOPQRabcdefghK  !"#$%&'()*+,-./0123456789:;<9None   :NonecReturns a relation which lists the names of relvars in the current session as well as its types. ;NoneTTA notification callback which logs the notification to stderr and does nothing else.LA synchronous function to start the project-m36 daemon given an appropriate . Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.<None             =None        =>?@>?A>?ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_``abcddefghijklmlnopqrstuvvwxyzz{|}~~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                             !W"#$%&'()*P+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !!!!!""`"]"^""""""""""k"""O"""""""""""""""""########$$%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&C''D'E(F)G)H)I*J*K*L*M+N+O+P+Q+R+S+T+U,V,W,X,Y,Z,[,\,],^,_,`,a-b-c-d-e-f-g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.{.|.}.~............////000000000111111111111111111111111111111111111111111122222222222222222222222222222234445555555555555555555555555555555555555555 5 5 5 5 5555555555555555555 5!5"5#5$5%5&6'6(6)6*6+6,6-6.6/6061626%6)66$6+73737474757576767777787879797:7:7;7;7<7<7=7=7>7>7?7?7@7@7A7A7B7B7C7C7D7D7E7E7F7F7G7G7H7H7I7J7K7L7M7N7O7P7Q7R7S7T7U7V7W7X7Y7Z7[7\7]7^7_7`7a7b7c7d7e7f7g7h7i7j7k7l7m7n7o7p7q7r7s7t8u8v8w8x8y8z8{8|8}8~88888899999999999::::::::::::::::::::::::;;;;;<<<<<<<<<==      !"#$%&'(&project-m36-0.1-4hDd5qAZs6QAKl1BvigkeNProjectM36.ClientProjectM36.PersistProjectM36.MiscUtilsProjectM36.FileLock'ProjectM36.DatabaseContextFunctionErrorProjectM36.AtomFunctionErrorProjectM36.BaseProjectM36.DataTypes.Primitive"ProjectM36.DisconnectedTransactionProjectM36.FunctionalDependencyProjectM36.TransactionProjectM36.TypeConstructorProjectM36.DataConstructorDefProjectM36.TypeConstructorDefProjectM36.DataTypes.MaybeProjectM36.DataTypes.ListProjectM36.ErrorProjectM36.AttributeProjectM36.AtomTypeProjectM36.AttributeNames"ProjectM36.DatabaseContextFunctionProjectM36.ScriptSessionProjectM36.SessionProjectM36.AtomFunctionBodyProjectM36.DataTypes.DateTimeProjectM36.DataTypes.DayProjectM36.AtomFunctionProjectM36.DataTypes.EitherProjectM36.DataTypes.BasicProjectM36.AtomProjectM36.TupleProjectM36.Relation.Show.CSVProjectM36.TupleSetProjectM36.Relation"ProjectM36.AtomFunctions.PrimitiveProjectM36.AtomFunctions.BasicProjectM36.Transaction.PersistProjectM36.AtomableProjectM36.DatabaseContextProjectM36.InclusionDependencyProjectM36.KeyProjectM36.DateExamplesProjectM36.Relation.Parse.CSV ProjectM36.Relation.Show.GnuplotProjectM36.Relation.Show.HTMLProjectM36.Relation.Show.TermProjectM36.Sessions!ProjectM36.TransactionGraph.MergeProjectM36.RelationalExpressionProjectM36.IsomorphicSchemaProjectM36.NotificationsProjectM36.StaticOptimizerProjectM36.TransactionGraph)ProjectM36.TransGraphRelationalExpression!ProjectM36.Server.RemoteCallTypes#ProjectM36.TransactionGraph.PersistProjectM36.Server.ConfigProjectM36.Server.EntryPointsProjectM36.ServerProjectM36.Server.ParseArgs ProjectM36.TransactionGraph.Show0distributed-process-0.6.6-9FMMuFy6nam1rRJFUNfEc0*Control.Distributed.Process.Internal.Types nodeAddressNodeIdDiskSync NoDiskSync FsyncDiskSync writeFileSync renameSyncwriteBSFileSyncdupesLockTypeReadLock WriteLock lockStructlockFile unlockFileDatabaseContextFunctionError DatabaseContextFunctionUserError%$fGenericDatabaseContextFunctionError $fEqDatabaseContextFunctionError"$fShowDatabaseContextFunctionError$$fBinaryDatabaseContextFunctionError$$fNFDataDatabaseContextFunctionErrorAtomFunctionErrorAtomFunctionUserErrorAtomFunctionTypeMismatchErrorAtomFunctionBytesDecodingError$fGenericAtomFunctionError$fEqAtomFunctionError$fShowAtomFunctionError$fBinaryAtomFunctionError$fNFDataAtomFunctionErrorDatabaseContextFunctionsDatabaseContextFunction dbcFuncName dbcFuncType dbcFuncBodyDatabaseContextFunctionBodyDatabaseContextFunctionBodyType!DatabaseContextFunctionBodyScriptDatabaseContextFunctionName MergeStrategyUnionMergeStrategyUnionPreferMergeStrategySelectedBranchMergeStrategy TupleExpr TupleExprBaseAttributeExprBaseAttributeAndTypeNameExprNakedAttributeExpr AttributeExprPersistenceStrategy NoPersistenceMinimalPersistenceCrashSafePersistenceAttributeNamesInvertedAttributeNamesUnionAttributeNamesIntersectAttributeNames AtomFunction atomFuncName atomFuncType atomFuncBodyAtomFunctionBodyAtomFunctionBodyTypeAtomFunctionBodyScriptAtomFunctionName AtomFunctionsExtendTupleExprExtendTupleExprBaseAttributeExtendTupleExpr AtomExprBaseAttributeAtomExpr NakedAtomExprFunctionAtomExprRelationAtomExprConstructedAtomExprAtomExprDisconnectedTransaction DirtyFlag Transaction TransactionIdTransactionInfoMergeTransactionInfoTransactionGraphTransactionHeadsHeadNameRestrictionPredicateExprBase TruePredicate AndPredicate OrPredicate NotPredicateRelationalExprPredicateAtomExprPredicateAttributeEqualityPredicateRestrictionPredicateExprDatabaseContextIOExprAddAtomFunctionAddDatabaseContextFunctionDatabaseContextExpr NoOperationDefineUndefineAssignInsertDeleteUpdateAddInclusionDependencyRemoveInclusionDependencyAddNotificationRemoveNotificationAddTypeConstructorRemoveTypeConstructorRemoveAtomFunctionRemoveDatabaseContextFunctionExecuteDatabaseContextFunction MultipleExprDatabaseContextExprNameAttributeNameAtomExprMapInclusionDependency IncDepNameDatabaseContextinclusionDependenciesrelationVariables atomFunctions dbcFunctions notificationstypeConstructorMappingSchemaIsomorphsSchemaIsomorph IsoRestrict IsoRenameIsoUnionSchemaSchemas Subschemas SchemaNameRelationVariablesInclusionDependenciesDataConstructorDefArg$DataConstructorDefTypeConstructorArg DataConstructorDefTypeVarNameArgDataConstructorDefsDataConstructorDef AtomTypeNameDataConstructorNameTypeConstructorArgNameTypeConstructorNameTypeConstructorMappingTypeConstructorADTypeConstructorPrimitiveTypeConstructor TypeVariableTypeConstructorDefADTypeConstructorDefPrimitiveTypeConstructorDef TypeVarName Notification changeExpr reportExpr NotificationsNotificationNameRelationalExprBaseMakeRelationFromExprsMakeStaticRelationExistingRelationRelationVariableProjectUnionJoinRename DifferenceGroupUngroupRestrictEquals NotEqualsExtendRelationalExpr RelVarNameRelationCardinality CountableFiniteRelation RelationTupleRelationTupleSetasList Attributes Attribute AttributeName TypeVarMapAtomType IntAtomTypeDoubleAtomType TextAtomType DayAtomTypeDateTimeAtomTypeByteStringAtomType BoolAtomTypeRelationAtomTypeConstructedAtomTypeTypeVariableTypeAtomIntAtom DoubleAtomTextAtomDayAtom DateTimeAtomByteStringAtomBoolAtom RelationAtomConstructedAtom StringTypeisRelationAtomTypeattributesEqualsortedAttributesIndicestransactionsForGraphtransactionHeadsForGraph transactionIdtransactionInfo$fEqDatabaseContextFunction!$fHashableDatabaseContextFunction#$fNFDataDatabaseContextFunctionBody$fBinaryTupleExprBase$fShowAtomFunction$fEqAtomFunction$fHashableAtomFunction$fShowAtomFunctionBody$fNFDataAtomFunctionBody$fBinaryExtendTupleExprBase$fBinaryAtomExprBase$fOrdTransaction$fEqTransaction$fBinaryTransactionInfo$$fBinaryRestrictionPredicateExprBase$fBinaryInclusionDependency$fBinaryRelationalExprBase$fBinaryRelation$fHashableRelation$fNFDataRelation $fEqRelation$fNFDataRelationTuple$fEqRelationTuple$fBinaryRelationTuple$fHashableRelationTuple$fNFDataRelationTupleSet$fEqRelationTupleSet$fReadRelation$fHashableAttribute $fHashableMap $fBinaryDay$fBinaryUTCTime$fHashableAtom$fEqRelationCardinality$fShowRelationCardinality$fGenericRelationCardinality$fOrdRelationCardinality $fEqAtomType$fNFDataAtomType$fGenericAtomType$fBinaryAtomType$fShowAtomType $fEqAttribute$fShowAttribute$fGenericAttribute$fNFDataAttribute$fBinaryAttribute$fShowTypeConstructor$fGenericTypeConstructor$fBinaryTypeConstructor$fEqTypeConstructor$fNFDataTypeConstructor$fShowTypeConstructorDef$fGenericTypeConstructorDef$fBinaryTypeConstructorDef$fEqTypeConstructorDef$fNFDataTypeConstructorDef$fEqAtom $fShowAtom $fBinaryAtom $fNFDataAtom $fGenericAtom$fShowRelation$fGenericRelation$fHashableRelationTupleSet$fShowRelationTupleSet$fGenericRelationTupleSet$fBinaryRelationTupleSet$fShowRelationTuple$fGenericRelationTuple$fShowDataConstructorDefArg$fGenericDataConstructorDefArg$fBinaryDataConstructorDefArg$fEqDataConstructorDefArg$fNFDataDataConstructorDefArg$fEqDataConstructorDef$fShowDataConstructorDef$fBinaryDataConstructorDef$fGenericDataConstructorDef$fNFDataDataConstructorDef$fShowTransactionInfo$fGenericTransactionInfo$fGenericAtomFunction$fNFDataAtomFunction$fEqAttributeNames$fShowAttributeNames$fGenericAttributeNames$fBinaryAttributeNames$fNFDataAttributeNames$fShowPersistenceStrategy$fReadPersistenceStrategy$fEqAttributeExprBase$fShowAttributeExprBase$fGenericAttributeExprBase$fBinaryAttributeExprBase$fNFDataAttributeExprBase$fEqTupleExprBase$fShowTupleExprBase$fGenericTupleExprBase$fNFDataTupleExprBase$fEqAtomExprBase$fShowAtomExprBase$fGenericAtomExprBase$fNFDataAtomExprBase$fShowRelationalExprBase$fEqRelationalExprBase$fGenericRelationalExprBase$fNFDataRelationalExprBase$fShowExtendTupleExprBase$fEqExtendTupleExprBase$fGenericExtendTupleExprBase$fNFDataExtendTupleExprBase"$fShowRestrictionPredicateExprBase $fEqRestrictionPredicateExprBase%$fGenericRestrictionPredicateExprBase$$fNFDataRestrictionPredicateExprBase$fGenericSchemaIsomorph$fBinarySchemaIsomorph$fShowSchemaIsomorph$fGenericSchema$fBinarySchema$fShowInclusionDependency$fEqInclusionDependency$fGenericInclusionDependency$fNFDataInclusionDependency$fShowNotification$fEqNotification$fBinaryNotification$fGenericNotification$fNFDataNotification$fEqMergeStrategy$fShowMergeStrategy$fBinaryMergeStrategy$fGenericMergeStrategy$fNFDataMergeStrategy$fShowDatabaseContextExpr$fEqDatabaseContextExpr$fBinaryDatabaseContextExpr$fGenericDatabaseContextExpr$fShowDatabaseContextIOExpr$fEqDatabaseContextIOExpr$fGenericDatabaseContextIOExpr$fBinaryDatabaseContextIOExpr $fGenericDatabaseContextFunction$fNFDataDatabaseContextFunction$fNFDataDatabaseContext$fGenericDatabaseContextprimitiveTypeConstructorMappingintTypeConstructordoubleTypeConstructortextTypeConstructordayTypeConstructoratomTypeForAtomconcreteDatabaseContextschemasparentIdFunctionalDependency,inclusionDependenciesForFunctionalDependencytransactionParentIdstransactionChildIdstransactionSetChildren!filterTransactionInfoTransactions filterParentfilterTransaction subschemasname argumentstypeVarsemptyDataConstructorfieldstypeVarsInDefArg maybeAtomTypemaybeTypeConstructorMappingmaybeAtomFunctions listAtomTypelistTypeConstructorMapping listLength listMaybeHeadlistAtomFunctions ServerErrorRequestTimeoutErrorProcessDiedError SchemaErrorRelVarReferencesMissingRelVarInReferencedMoreThanOnceRelVarOutReferencedMoreThanOnceScriptCompilationErrorTypeCheckCompilationErrorSyntaxErrorCompilationErrorScriptCompilationDisabledErrorOtherScriptCompilationError MergeErrorSelectedHeadMismatchMergeErrorPreferredHeadMissingMergeError$StrategyViolatesConstraintMergeErrorInvalidMergeStrategyError)DisconnectedTransactionNotAMergeHeadError#StrategyViolatesComponentMergeError*StrategyViolatesRelationVariableMergeError)StrategyViolatesTypeConstructorMergeErrorPersistenceErrorInvalidDirectoryErrorMissingTransactionErrorRelationalErrorNoSuchAttributeNamesError TupleAttributeCountMismatchErrorTupleAttributeTypeMismatchErrorAttributeCountMismatchErrorAttributeNamesMismatchErrorAttributeNameInUseError!AttributeIsNotRelationValuedErrorCouldNotInferAttributesRelVarNotDefinedErrorRelVarAlreadyDefinedError!RelVarAssignmentTypeMismatchErrorInclusionDependencyCheckError!InclusionDependencyNameInUseError$InclusionDependencyNameNotInUseError ParseErrorPredicateExpressionError NoCommonTransactionAncestorErrorNoSuchTransactionErrorRootTransactionTraversalError$HeadNameSwitchingHeadProhibitedErrorNoSuchHeadNameError%NewTransactionMayNotHaveChildrenErrorParentCountTraversalError NewTransactionMissingParentErrorTransactionIsNotAHeadErrorTransactionGraphCycleErrorSessionIdInUseErrorNoSuchSessionErrorFailedToFindTransactionErrorTransactionIdInUseErrorNoSuchFunctionErrorNoSuchTypeConstructorNameTypeConstructorAtomTypeMismatchAtomTypeMismatchErrorTypeConstructorNameMismatch*AtomTypeTypeConstructorReconciliationErrorDataConstructorNameInUseError)DataConstructorUsesUndeclaredTypeVariableTypeConstructorTypeVarsMismatchTypeConstructorTypeVarMissing$TypeConstructorTypeVarsTypesMismatchDataConstructorTypeVarsMismatch'AtomFunctionTypeVariableResolutionError AtomFunctionTypeVariableMismatchAtomTypeNameInUseError/IncompletelyDefinedAtomTypeWithConstructorErrorAtomTypeNameNotInUseErrorFunctionNameInUseErrorFunctionNameNotInUseErrorEmptyCommitErrorFunctionArgumentCountMismatchNoSuchDataConstructorErrorNoSuchTypeConstructorErrorInvalidAtomTypeNameAtomTypeNotSupportedAtomOperatorNotSupportedEmptyTuplesErrorAtomTypeCountErrorAtomFunctionTypeErrorPrecompiledFunctionRemoveError)RelationValuedAttributesNotSupportedErrorNotificationNameInUseErrorNotificationNameNotInUseError ImportError ExportErrorUnhandledExceptionErrorMergeTransactionError ScriptErrorDatabaseLoadErrorSubschemaNameInUseErrorSubschemaNameNotInUseErrorSchemaCreationErrorImproperDatabaseStateErrorMultipleErrors someErrors!$fExceptionScriptCompilationError$fNFDataMergeError$fShowPersistenceError$fEqPersistenceError$fGenericPersistenceError$fBinaryPersistenceError$fNFDataPersistenceError$fShowMergeError$fEqMergeError$fGenericMergeError$fBinaryMergeError$fShowScriptCompilationError$fEqScriptCompilationError$fGenericScriptCompilationError$fBinaryScriptCompilationError$fNFDataScriptCompilationError$fShowSchemaError$fEqSchemaError$fGenericSchemaError$fBinarySchemaError$fNFDataSchemaError$fShowRelationalError$fEqRelationalError$fGenericRelationalError$fBinaryRelationalError$fNFDataRelationalError$fGenericServerError$fBinaryServerError$fEqServerErrorarityemptyAttributesnullattributesFromList attributeNameatomType atomTypes addAttributejoinAttributes addAttributesdeleteAttributeNamerenameAttributerenameAttributesatomTypeForAttributeNameattributeForNameattributesForNamesattributeNameSetattributeNamesattributesContainedattributeNamesContainednonMatchingAttributeNameSetmatchingAttributeNameSetattributeNamesNotContainedsortedAttributeNameListattributesDifferencevectorUniqueifyverifyAttributesattributesAsMapunion intersectionfindDataConstructoratomTypeForDataConstructorName atomTypeForDataConstructorDefArg!isValidAtomTypeForTypeConstructoratomTypeForDataConstructorresolveDataConstructorTypeVars!resolveDataConstructorArgTypeVarsresolveTypeConstructorTypeVarsvalidateTypeConstructorDefatomTypeForTypeConstructorfindTypeConstructorresolveAtomTyperesolveAtomTypesInTypeVarMapresolveTypeInAtomresolveTypesInTuplevalidateAtomType validateTupleatomTypeVerifytypeVarMapsVerifyprettyAtomTypeprettyAttributeresolveTypeVariablesresolveTypeVariableresolveFunctionReturnValueemptyall%projectionAttributesForAttributeNamesinvertAttributeNamesemptyDatabaseContextFunctiondatabaseContextFunctionForNameevalDatabaseContextFunctionbasicDatabaseContextFunctions#precompiledDatabaseContextFunctions!isScriptedDatabaseContextFunctiondatabaseContextFunctionScript!databaseContextFunctionReturnType%createScriptedDatabaseContextFunctionScriptSessionErrorScriptSessionLoadError ScriptSessionhscEnvatomFunctionBodyTypedbcFunctionBodyTypeinitScriptSession addImportshowType mkTypeForName compileScripttypeCheckScript$fShowScriptSessionErrorSession SessionIddefaultSchemaNamedisconnectedTransactionisDirty schemaName setSchemaNamecompiledAtomFunctionBodydateTimeAtomFunctionsdayAtomFunctionsdayTypeConstructorMappingfoldAtomFuncTypeatomFunctionForNameemptyAtomFunctioncompiledAtomFunctionevalAtomFunctionextractAtomFunctionTypeisScriptedAtomFunctionatomFunctionScriptcreateScriptedAtomFunctioneitherAtomTypeeitherTypeConstructorMappingeitherAtomFunctionsbasicTypeConstructorMappingrelationForAtommakeAtomFromText atomToText emptyTuple tupleSizetupleAttributeNameSettupleAttributes tupleAssocs tupleAtomsatomForAttributeNameatomsForAttributeNamesvectorIndicesForAttributeNamesrelationForAttributeNametupleRenameAttributemkRelationTuplemkRelationTuplesmkRelationTupleFromMapsingleTupleSetJoinsingleTupleJoin vectorUnion tupleExtendtupleAtomExtendtupleSortedAssocs tupleProjecttupleIntersectionupdateTupleWithAtoms tupleToMap verifyTuple reorderTuple RecordAtomunAtomRecordRelationTupleunTuple relationAsCSV$fToFieldRecordAtom#$fDefaultOrderedRecordRelationTuple"$fToNamedRecordRecordRelationTuple emptyTupleSetsingletonTupleSetverifyTupleSet mkTupleSetmkTupleSetFromList attributesatomTypeForNamemkRelationFromListemptyRelationWithAttrs mkRelationmkRelationDeferVerifymkRelationFromTuples relationTrue relationFalsesingletonTupleprojectrenamedegree cardinalitygroup restrictEqungroup tupleUngroupattributesForRelvalrestrictjoin differencerelMap relMogrifyrelFoldimageRelationFortypesAsRelationrelationVariablesAsRelationrandomizeTupleOrderprimitiveAtomFunctionsintAtomFuncLessThan boolAtomNot relationSum relationCount relationMax relationMincastIntbasicAtomFunctionsprecompiledAtomFunctionsgetDirectoryNamestempTransactionDirtransactionDirtransactionInfoPath relvarsDir incDepsDir atomFuncsDir dbcFuncsDir typeConsPathsubschemasPathreadTransactionwriteTransaction writeRelVar writeRelVars readRelVarswriteAtomFuncs readAtomFuncs writeAtomFunc readAtomFunc writeDBCFuncs writeDBCFunc readDBCFuncs readDBCFunc writeIncDep writeIncDeps readIncDep readIncDepsreadSubschemaswriteSubschemaswriteTypeConstructorMappingreadTypeConstructorMapping AtomableGtoAtomG fromAtomG toAtomTypeGtoAtomsGtoDatabaseContextExprGgetConstructorsGgetConstructorArgsGAtomabletoAtomfromAtom toAtomTypetoDatabaseContextExpr$fAtomableGTYPE:+:$fAtomableGTYPE:*:$fAtomableGTYPEU1$fAtomableGTYPEK1$fAtomableGTYPEM1$fAtomableGTYPEM10$fAtomableGTYPEM11 $fAtomable[]$fAtomableRelation$fAtomableBool$fAtomableByteString$fAtomableUTCTime $fAtomableDay$fAtomableText$fAtomableDouble $fAtomableInt$databaseContextAsDatabaseContextExprbasicDatabaseContextinclusionDependenciesAsRelationinclusionDependencyForKeydatabaseContextExprForUniqueKey databaseContextExprForForeignKey dateExamples suppliersRelsupplierProductsRel productsRelCsvImportError CsvParseErrorAttributeMappingErrorHeaderAttributeMismatchErrorcsvDecodeOptionsmakeAtomFromCSVText csvAsRelation$fShowCsvImportError PlotErrorInvalidAttributeCountErrorInvalidAttributeTypeErrorintFromAtomIndexgraph1DRelationpoints1DRelationgraph2DRelationpoints2DRelationgraph3DRelationpoints3DRelation plotRelation$fShowPlotErrorattributesAsHTMLrelationAsHTML writeHTMLwriteRel tupleAsHTMLtupleSetAsHTMLTableCellTermSize termLengthboxVboxHboxTLboxTRboxBLboxBRboxLBboxRBboxTBboxBBboxCdboxHdboxLdboxRaddRow cellLocations breakLines cellSizesrelationAsTable showParensshowAtom renderTable renderHeader renderHBarleftPaddedString renderRow renderBodyorderedAttributesorderedAttributeNames repeatString showRelationSessions stmMapToListuuidAtomsessionsAsRelationMergePreference PreferFirst PreferSecond PreferNeitherunionMergeMapsunionMergeRelationunionMergeRelVarsunionMergeAtomFunctions unionMergeTypeConstructorMappingRelationalExprState DatabaseStateDatabaseStateElems ResultAccumresultAccumFuncresultAccumResultResultAccumFuncResultAccumNameRelationalExprStateElemsRelationalExprStateTupleElemsRelationalExprStateAttrsElemsDatabaseContextExprDetailsCountUpdatedTuplesdatabaseContextExprDetailsFuncfreshDatabaseStatemkRelationalExprState"mergeTuplesIntoRelationalExprState&mergeAttributesIntoRelationalExprStategetStateContextputStateContextstateElemsContextsetStateElemsContextevalRelationalExpr setRelVar deleteRelVarevalDatabaseContextExprevalDatabaseContextIOExprupdateTupleWithAtomExprscheckConstraintstypeForRelationalExprcontextWithEmptyTupleSetsliftEpredicateRestrictionFiltertupleExprCheckNewAttrNameextendTupleExpressionProcessor evalAtomExprtypeFromAtomExprverifyAtomExprTypes evalAttrExpr evalTupleExpr$fShowRelationalExprStateElems SchemaExpr AddSubschemaRemoveSubschema isomorphsvalidateSchemainvertisomorphInRelVarNamesisomorphsInRelVarNamesisomorphOutRelVarNamesisomorphsOutRelVarNamesvalidateRelationalExprInSchemaprocessRelationalExprInSchema#validateDatabaseContextExprInSchema"processDatabaseContextExprInSchema&processDatabaseContextExprSchemaUpdate'processDatabaseContextExprSchemasUpdate relExprMorphrelExprMogrifydatabaseContextExprMorph"applyRelationalExprSchemaIsomorphsinclusionDependencyInSchemainclusionDependenciesInSchemarelationVariablesInSchema%applyRelationVariablesSchemaIsomorphs%applySchemaIsomorphsToDatabaseContextcreateIncDepsForIsomorphevalSchemaExpr$fGenericSchemaExpr$fBinarySchemaExpr$fShowSchemaExprnotificationChanges!applyStaticRelationalOptimizationapplyStaticDatabaseOptimization applyStaticPredicateOptimizationROTransactionGraphOperator ShowGraphTransactionGraphOperator JumpToHeadJumpToTransactionBranch DeleteBranchMergeTransactionsCommitRollback CommitOptionAllowEmptyCommitOptionForbidEmptyCommitOptionIgnoreEmptyCommitOptionTransactionIdHeadBacktrack TransactionIdHeadParentBacktrack TransactionIdHeadBranchBacktrackTransactionIdLookupTransactionIdHeadNameLookupisCommitbootstrapTransactionGraphemptyTransactionGraphtransactionForHeadheadListheadNameForTransactiontransactionForIdtransactionsForIdsisRootTransactionparentTransactionschildTransactions addBranchaddDisconnectedTransactionaddTransactionToGraph validateGraphwalkParentTransactionswalkChildTransactions evalGraphOpgraphAsRelationtransactionParentsRelationcreateMergeTransactionvalidateHeadNamesubGraphOfFirstCommonAncestorpathToTransactionmergeTransactionsshowTransactionStructureXshowGraphStructureXfilterSubGraphcreateUnionMergeTransactionlookupTransaction traverseGraphbacktrackGraph $fShowTransactionIdHeadBacktrack$fEqTransactionIdHeadBacktrack"$fBinaryTransactionIdHeadBacktrack#$fGenericTransactionIdHeadBacktrack$fShowTransactionIdLookup$fEqTransactionIdLookup$fBinaryTransactionIdLookup$fGenericTransactionIdLookup$fEqCommitOption$fShowCommitOption$fBinaryCommitOption$fGenericCommitOption$fEqTransactionGraphOperator$fShowTransactionGraphOperator $fBinaryTransactionGraphOperator!$fGenericTransactionGraphOperator $fShowROTransactionGraphOperatorTransGraphAttributeExprTransGraphAtomExpr"TransGraphRestrictionPredicateExprTransGraphTupleExprTransGraphExtendTupleExprTransGraphRelationalExprevalTransGraphRelationalExprevalTransGraphTupleExprevalTransGraphAtomExpr&evalTransGraphRestrictionPredicateExprevalTransGraphExtendTupleExprevalTransGraphAttributeExpr TestTimeoutRetrieveCurrentSchemaNameRetrieveRelationVariableSummaryRetrieveAtomTypesAsRelation CloseSessionCreateSessionAtHeadCreateSessionAtCommitRetrieveHeadTransactionIdRetrieveTransactionGraph"RetrievePlanForDatabaseContextExprRetrieveInclusionDependenciesExecuteSetCurrentSchemaExecuteSchemaExprExecuteTypeForRelationalExprExecuteHeadNameExecuteTransGraphRelationalExprExecuteGraphExprExecuteDatabaseContextIOExprExecuteDatabaseContextExprExecuteRelationalExprLogoutLogin $fBinaryLogin$fGenericLogin$fBinaryLogout$fGenericLogout$fBinaryExecuteRelationalExpr$fGenericExecuteRelationalExpr"$fBinaryExecuteDatabaseContextExpr#$fGenericExecuteDatabaseContextExpr$$fBinaryExecuteDatabaseContextIOExpr%$fGenericExecuteDatabaseContextIOExpr$fBinaryExecuteGraphExpr$fGenericExecuteGraphExpr'$fBinaryExecuteTransGraphRelationalExpr($fGenericExecuteTransGraphRelationalExpr$fBinaryExecuteHeadName$fGenericExecuteHeadName$$fBinaryExecuteTypeForRelationalExpr%$fGenericExecuteTypeForRelationalExpr$fBinaryExecuteSchemaExpr$fGenericExecuteSchemaExpr$fBinaryExecuteSetCurrentSchema $fGenericExecuteSetCurrentSchema%$fBinaryRetrieveInclusionDependencies&$fGenericRetrieveInclusionDependencies*$fBinaryRetrievePlanForDatabaseContextExpr+$fGenericRetrievePlanForDatabaseContextExpr $fBinaryRetrieveTransactionGraph!$fGenericRetrieveTransactionGraph!$fBinaryRetrieveHeadTransactionId"$fGenericRetrieveHeadTransactionId$fBinaryCreateSessionAtCommit$fGenericCreateSessionAtCommit$fBinaryCreateSessionAtHead$fGenericCreateSessionAtHead$fBinaryCloseSession$fGenericCloseSession#$fBinaryRetrieveAtomTypesAsRelation$$fGenericRetrieveAtomTypesAsRelation'$fBinaryRetrieveRelationVariableSummary($fGenericRetrieveRelationVariableSummary!$fBinaryRetrieveCurrentSchemaName"$fGenericRetrieveCurrentSchemaName$fBinaryTestTimeout$fGenericTestTimeout LockFileHashtransactionLogPath headsPath lockFilePathsetupDatabaseDirbootstrapDatabaseDir openLockFiletransactionGraphPersist"transactionHeadTransactionsPersisttransactionGraphHeadsPersisttransactionGraphHeadsLoadtransactionGraphLoadreadTransactionIfNecessarywriteGraphTransactionIdFile readGraphTransactionIdFileDigestreadGraphTransactionIdFileConnectionErrorSetupDatabaseDirectoryErrorIOExceptionErrorNoSuchDatabaseByNameError LoginError ConnectionInProcessConnectionRemoteProcessConnectionEvaluatedNotification notificationreportRelationConnectionInfoInProcessConnectionInfoRemoteProcessConnectionInfoRequestTimeoutExceptionRemoteProcessDiedExceptionNotificationCallback DatabaseNamePortHostnameemptyNotificationCallback createNodeIddefaultServerPortdefaultDatabaseNamedefaultHeadNamedefaultRemoteConnectionInforemoteDBLookupNameconnectProjectM36createSessionAtCommitcreateSessionAtHead addClientNode closeSessionclose closeRemote_currentSchemaNamesetCurrentSchemaNameexecuteRelationalExprexecuteDatabaseContextExprexecuteDatabaseContextIOExprexecuteGraphExprexecuteTransGraphRelationalExprexecuteSchemaExprcommitrollbackplanForDatabaseContextExprtransactionGraphAsRelationheadTransactionIdheadNameatomTypesAsRelationcallTestTimeout_transactionGraph_disconnectedTransaction_"$fExceptionRequestTimeoutException%$fExceptionRemoteProcessDiedException $fShowRemoteProcessDiedException$fEqRemoteProcessDiedException$fShowRequestTimeoutException$fEqRequestTimeoutException$fBinaryEvaluatedNotification$fEqEvaluatedNotification$fShowEvaluatedNotification$fGenericEvaluatedNotification$fBinaryNotificationMessage$fEqNotificationMessage$fShowNotificationMessage$fGenericNotificationMessage$fShowConnectionError$fEqConnectionError$fGenericConnectionError ServerConfigpersistenceStrategy databaseNamebindHostbindPort ghcPkgPathsperRequestTimeouttestModedefaultServerConfig$fShowServerConfigReplyTimeout timeoutOrDiehandleExecuteRelationalExpr handleExecuteDatabaseContextExpr"handleExecuteDatabaseContextIOExprhandleExecuteHeadName handleLoginhandleExecuteGraphExpr%handleExecuteTransGraphRelationalExpr"handleExecuteTypeForRelationalExpr#handleRetrieveInclusionDependencies(handleRetrievePlanForDatabaseContextExprhandleRetrieveTransactionGraphhandleRetrieveHeadTransactionIdhandleCreateSessionAtCommithandleCreateSessionAtHeadhandleCloseSession!handleRetrieveAtomTypesAsRelation%handleRetrieveRelationVariableSummaryhandleRetrieveCurrentSchemaNamehandleExecuteSchemaExpr handleLogouthandleTestTimeoutserverDefinition initServer registerDBloggingNotificationCallback launchServerparseArgsWithDefaultsparsePersistenceStrategyparseDatabaseName parseHostname parsePortparseGhcPkgPaths parseTimeout parseConfigparseConfigWithDefaultsshowTransactionStructureshowGraphStructurecHSDirectoryFsync atomicRename syncHandle syncDirectorydirectoryFsync ClientNodesNotificationMessage"processTransactionGraphPersistenceRemoteProcessConnectionConf rLocalNode rProcessId rTransportInProcessConnectionConfipPersistenceStrategy ipClientNodes ipSessionsipTransactionGraphipScriptSession ipLocalNode ipTransportipLocksTransactionGraphLockHandleEvaluatedNotifications GhcPkgPathcreateLocalNodenotificationListenerstartNotificationListenercreateScriptSessionconnectPersistentProjectM36createSessionAtCommit_excMaybe excEitherrunProcessResult safeLogin remoteCallsessionForSessionIdschemaForSessionIdsessionAndSchemaexecuteGraphExprSTM_executeCommitExprSTM_sendNotificationsreadGraphTransactionIdDigesttypeForRelationalExprSTM headNameSTM_