h&?      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                            ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " # $ $ $ $ $ $ $ $ $ $ $ $ % & & & & & & & & & & & ' ( ( ) ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + + + + + + + + + + , , - - - - - - - - - - - - - - - - - - - - - - - - - - - . . . . . . / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 9 9 : : : : : : : : : : ; ; ; ; ; ; < < < < < < < < < < = = = = = = = = = = > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ? ? ? @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B B B B B B                                            C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C CCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDEEEEEEEEEEEEFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHIJJJJKKKKKKKLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^____________________________________________________________________________________________________________________________________________``aaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccddddddddddddddddddeeeeeeeeeeeeeeeeffffffffffffffffffffffffff Safe-Inferred";=7   Safe-Inferred";=8# Safe-Inferred"8Q Safe-Inferred"8 ! "#$%&'( $"#%&'(!  Safe-Inferred";?8*,+*,+ Safe-Inferred"89:;=?Q(; project-m36Represents stored, user-created or built-in functions which can operates of types such as Atoms or DatabaseContexts.E project-m36After 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)F project-m36Similar to a union merge, but, on conflict, prefer the unmerged section (relvar, function, etc.) from the branch named as the argument.G project-m36Similar 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.N project-m364Dynamically create a tuple from attribute names and ts.P project-m36Create attributes dynamically.U project-m36The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.V project-m36.no filesystem persistence/memory-only databaseW project-m36fsync off, not crash-safeX project-m36full fsync to disk (flushes kernel and physical drive buffers to ensure that the transaction is on non-volatile storage)[ project-m36An AtomFunction has a name, a type, and a function body to execute when called.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").h project-m360Used in tuple creation when creating a relation.j project-m36An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.w project-m36The 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.{ project-m36Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.} project-m36Every transaction has context-specific information attached to it. The TransactionDiffs represent child/edge relationships to previous transactions (branches or continuations of the same branch). project-m36The transaction graph is the global database's state which references every committed transaction. project-m36A 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. project-m36Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation. project-m36Adding an atom function should be nominally a DatabaseExpr except for the fact that it cannot be performed purely. Thus, we create the DatabaseContextIOExpr. project-m369Database context expressions modify the database context. project-m36Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally. project-m36 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. project-m36Every transaction has one concrete database context and any number of isomorphic subschemas. project-m36Used to define a data constructor in a type constructor context such as Left a | Right b project-m36Found in data constructors and type declarations: Left (Either Int Text) | Right Int project-m362Metadata definition for type constructors such as data Either a b. project-m36When the changeExpr returns a different result in the database context, then the reportExpr is triggered and sent asynchronously to all clients. project-m36A relational expression represents query (read) operations on a database. project-m36Extract a relation from an < that is a nested relation (a relation within a relation).  project-m361Relation variables are identified by their names. project-m36>Used to represent the number of tuples in a relation.  project-m36/A tuple is a set of attributes mapped to their  values. project-m365The relation's tuple set is the body of the relation. project-m36" represent the head of a relation. project-m36;A relation's type is composed of attribute names and types. project-m36=?<@ABCDGFEHIJKLMNOPRQSTUXWVYZ[`_^]\abcdefghijqponmlkrstuvwxyz{|}~}~|{yzwxvutsrjqponmlkhigfedcba[`_^]\ZYUXWVTSPRQNOMLJKIHDGFECBA@;>=?<7:986543  Safe-Inferred"Wo project-m36return `Just transid` if this GraphRefRelationalExpr refers to just one transaction in the graph. This is useful for determining if certain optimizations can apply. project-m36Return True if two s both refer exclusively to the same transaction (or none at all).  Safe-Inferred"W  Safe-Inferred"W  Safe-Inferred"X-  Safe-Inferred"X project-m36Return the type of an . Safe-Inferred"X Safe-Inferred"Y Safe-Inferred"YS Safe-Inferred"Y Safe-Inferred"Z# project-m36Coalesce a bunch of AttributeNames into a single AttributeNames. Safe-Inferred"Z\ Safe-Inferred"Z Safe-Inferred"Z Safe-Inferred"Z Safe-Inferred"[ Safe-Inferred"[F Safe-Inferred"[ Safe-Inferred"589:;=?\ project-m36Interval project-m36ExistsSubQuery Select | UniqueSubQuery Select | ScalarSubQuery Select Safe-Inferred";=?_@ Safe-Inferred";=?_{ Safe-Inferred";=?` project-m36Used to represent constraints which are defined next to a column name and type. Safe-Inferred";=`       Safe-Inferred"cD  project-m36 Left-biased union of attributes.+ +  Safe-Inferred"d  ! Safe-Inferred"1fT  project-m36Load either a .o or dynamic library based on the file name's extension.Load a function from an relocatable object file (.o or .so) If a modulesDir is specified, only load a path relative to the modulesDir (no ..)  project-m36load .o files only  project-m36 load .so .dynlib .dll files only  project-m36determine which object mode to use based on the file name's extension  project-m36Configure a GHC environment/session which we will use for all script compilation.  " Safe-Inferred"5?f# Safe-Inferred"5?g $ Safe-Inferred"hn  project-m36Represents a pointer into the database's transaction graph which the s 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. % Safe-Inferred"i-  project-m36Utility function for tracing with ghc-events-analyze using START and STOP markers  & Safe-Inferred"k  project-m36Return 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.  project-m36Remove any child or parent transaction references not in the valud UUID set.  project-m361Return the singular context which is not virtual.  project-m362Returns all schemas including the concrete schema.  project-m36Returns all subschemas which are isomorphic or sub-isomorphic to the concrete schema. ' Safe-Inferred"lN  project-m36=Create a TransactionInfo with just one parent transaction ID.  ( Safe-Inferred"l|  ) Safe-Inferred"l  * Safe-Inferred"rI  project-m36Used to determine if the atom arguments can be used with the data constructor. | This is the entry point for type-checking from RelationalExpression.hs  project-m36Walks the data and type constructors to extract the type variable map.  project-m36Attempt to match the data constructor argument to a type constructor type variable.  project-m36Create an atom type iff all type variables are provided. Either Int Text -> ConstructedAtomType Either {Int , Text}  project-m36 See notes at  6. The typeFromRelation must not include any wildcards.  project-m36When 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.  project-m36Validate that the type is provided with complete type variables for type constructors.  project-m36Determine if two types are equal or compatible (including special handling for TypeVar x).  project-m363Determine if two typeVars are logically compatible.& & + Safe-Inferred"s , Safe-Inferred"sa  - Safe-Inferred"tF  project-m36An optimized form of tuple update which updates vectors efficiently.  project-m36Validate that the tuple has the correct attributes in the correct order  . Safe-Inferred"u;  project-m36Union two tuplesets while reordering their attribute/atom mapping properly.  / Safe-Inferred")*ww  project-m36Difference 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.  project-m36=Generate a randomly-ordered list of tuples from the relation.  project-m366Return a Relation describing the types in the mapping.  project-m36Randomly resort the tuples. This is useful for emphasizing that two relations are equal even when they are printed to the console in different orders.' ' 0 Safe-Inferred"x?  1 Safe-Inferred "5?z  project-m36restore slimmed tuple set to include single shared attributes list  project-m36A special instance of Serialise which cuts down on duplicate attributes- we should only serialise the attributes at the top-level and not duplicate them per tuple.  project-m36A special instance of Serialise which cuts down on duplicate attributes- we should only serialise the attributes at the top-level and not duplicate them per tuple. If we have an empty tupleset, we lack all attributes which is fine in this case.  2 Safe-Inferred"5?z3 Safe-Inferred";=?{  4 Safe-Inferred";=?{Q  5 Safe-Inferred";=?{  project-m36represents any SQL expression which can change the current transaction state such as  6 Safe-Inferred"}f  project-m363Return the underlying function to run the Function.  project-m364Return the text-based Haskell script, if applicable.  project-m36Change atom function definition to reference proper object file source. Useful when moving the object file into the database directory.  7 Safe-Inferred"} 8 Safe-Inferred"  project-m36Create a uniqueness constraint for the attribute names and relational expression. Note that constraint can span multiple relation variables.  project-m36 Create a  which can be used to add a uniqueness constraint to attributes on one relation variable.  project-m36Create a foreign key constraint from the first relation variable and attributes to the second.  9 Safe-Inferred"  : Safe-Inferred" ; Safe-Inferred"T  < Safe-Inferred"  = Safe-Inferred"  project-m36Create a junk named atom function for use with searching for an already existing function in the AtomFunctions HashSet.  project-m363AtomFunction constructor for compiled-in functions.  project-m36 Create a  which can be used to load a new atom function written in Haskell and loaded at runtime.  project-m36Used to mark functions which are loaded externally from the server. > Safe-Inferred"  ? Safe-Inferred"{  @ Safe-Inferred"  A Safe-Inferred"0<6  project-m36,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.  project-m36Creates DatabaseContextExpr necessary to load the type constructor and data constructor into the database.  B Safe-Inferred "<z  project-m36)Options that influence deriving behavior.  project-m36A function that translates record field names into attribute names.  project-m36(Types that can be converted to and from .deriving without customization: data Example = Example { foo :: Integer , bar :: Text } deriving (Generic) instance Tupleable Example"deriving with customization using ProjectM36.Tupleable.Deriving: data Example = Example { exampleFoo :: Integer , exampleBar :: Text } deriving stock (Generic) deriving (Tupleable) via Codec (Field (DropPrefix "example" >>> CamelCase)) Example  project-m36 Convert a  Traverseable of  s to an  . This is useful for converting, for example, a list of data values to a set of Insert expressions which can be used to add the values to the database.  project-m36 Convert a   to a create a  expression which can be used to create an empty relation variable. Use   to insert the actual tuple data. This function is typically used with gh.  project-m36'Convert a list of key attributes and a   value to an  expression. This expression flushes the non-key attributes of the value to a tuple with the matching key attributes.  project-m36'Convert a list of key attributes and a   value to a  expression. This expression deletes tuples matching the key attributes from the value.  project-m365The default options for deriving Tupleable instances.These options can be customized by using record update syntax. For example, defaultTupleableOptions { fieldModifier = \fieldName -> case Data.Text.stripPrefix "example" fieldName of Nothing -> fieldName Just attributeName -> attributeName }will result in record field names being translated into attribute names by removing the prefix "example" from the field names.   Safe-Inferred "19  project-m36Left to right composition. Requires the  TypeOperators extension to be enabled.  project-m36Right to left composition. Requires the  TypeOperators extension to be enabled.  project-m36Identity option.  project-m36&Convert to Train-Case. Will transform "fooBar" into  "Foo-Bar".  project-m36'Convert to spinal-case. will transform "fooBar" into  "foo-bar".  project-m36&Convert to snake_case. Will transform "fooBar" into  "foo_bar".  project-m36&Convert to PascalCase. Will transform  "foo_bar" into "FooBar".  project-m36%Convert to camelCase. Will transform  "foo_bar" into "fooBar".  project-m36&Convert to Title Case. Will transform "fooBar" into  "Foo Bar".  project-m36%Convert to lowercase. Will transform "FOOBAR" into "foobar".  project-m36%Convert to UPPERCASE. Will transform "foobar" into "FOOBAR".  project-m36Drop a suffix. DropSuffix "bar" will transform "foobar" into "foo".  project-m36Add a suffix. AddSuffix "bar" will transform "foo" into "foobar".  project-m36Drop a prefix. DropPrefix "bar" will transform "foobar" into "foo".  project-m36Add a prefix. AddPrefix "foo" will transform "bar" into "foobar".  project-m36.Types that can be used in options that modify  such as in  .  project-m36Change how record field names are translated into attribute names. For example, Field SnakeCasewill translate the field name fooBar into the attribute name foo_bar.  project-m36#Types that can be used as tags for  .  project-m362A newtype wrapper to allow for easier deriving of   instances with customization.The tag type variable can be used to specify options for converting the datatype to and from a  RelationTuple. For example, data Example = Example { exampleFoo :: Int , exampleBar :: Int } deriving stock (Generic) deriving (Tupleable) via Codec (Field (DropPrefix "example" >>> CamelCase)) Examplewill derive an instance of   where field names are translated into attribute names by dropping the prefix  "example"2 and then converting the result to camelCase. So  "exampleFoo" becomes "foo" and  "exampleBar" becomes "bar". Requires the DerivingGeneric and  DerivingVia extensions to be enabled..  C Safe-Inferred ")*# #  6 5 9  8 5 5 4 9 D Safe-Inferred"  E Safe-Inferred"L  F Safe-Inferred"G Safe-Inferred"?/ project-m36?where compiled modules are stored within the database directory%%H Safe-Inferred" project-m366Remove TransactionId markers on GraphRefRelationalExpr project-m36convert an existing database context into its constituent expression. I Safe-Inferred"J Safe-Inferred"K Safe-Inferred"DL Safe-Inferred"M Safe-Inferred"N Safe-Inferred";=? project-m36A Relation can be converted to a DataFrame for sorting, limits, and offsets. project-m36True iff dataframe features are required to execute this expression, False if this expression could be evaluated as a relational expression (no sorting, limit, or offset). project-m36>Returns a data frame expression without any sorting or limits.))O Safe-Inferred"5?P Safe-Inferred"D project-m36 project-m36Drop macros into the relational expression wherever they are referenced.Q Safe-Inferred"s  project-m36resolve UncommittedTransactionMarker whenever possible- this is important in the DatabaseContext in order to mitigate self-referencing loops for updates project-m36when running in persistent mode, this must be a Just value to a directory containing .o.so.dynlib files which the user has placed there for access to compiled functions project-m36The context is optionally passed down along in cases where the current context is uncommitted. project-m36Used to start a fresh database state for a new database context expression. project-m36Validate that the type of the AtomExpr matches the expected type. project-m363Look up the type's name and create a new attribute. project-m364Return a Relation describing the relation variables. project-m36An unoptimized variant of evalGraphRefRelationalExpr for testing. project-m36Optionally add type hints to resolve type variables. For example, if we are inserting into a known relvar, then we have its concrete type.  project-m36Ensure that the notification contains valid, type-checkable relational expressions. These relational expressions therefore become registered queries: queries which must remain valid.R Safe-Inferred" project-m36The incremental writer writes the transactions ids specified by the second argument.S Safe-Inferred"-  T Safe-Inferred " project-m36&Validated "group by" and "having" data project-m361mentioned in group by clause and uses aggregation project-m360mentioned in group by clause by not aggregations project-m36Used to note if columns are remapped to different attributes in order to mitigate attribute naming conflicts. project-m36Pass state down to subselect, but discard any state changes from the subselect processing. project-m36Insert another table into the TableContext. Returns an alias map of any columns which could conflict with column names already present in the TableContext so that they can be optionally renamed. project-m36When a column is mentioned, it may need to be aliased. The table name must already be in the table context so that we can identify that the attribute exists. Without a table name, we must look for a uniquely named column amongst all tables. Thus, we pre-emptively eliminate duplicate column names. project-m36Find a column name or column alias in the underlying table context. Returns key into table context. project-m36"non ConvertM version of findColumn project-m36Search the TableContext for a column alias remapping for the given column name. This function can change the state context if column names conflict. project-m36-Slightly different processing for subselects. project-m36Convert TableRefs after the first one (assumes all additional TableRefs are for joins). Returns the qualified name key that was added to the map, the underlying relexpr (not aliased so that it can used for extracting type information), and the new table context map project-m36Used in join condition detection necessary for renames to enable natural joins. project-m36Used to remap SQL qualified names to new names to prevent conflicts in join conditions. project-m36If the restriction includes a EXISTS expression, we must rename all attributes at the top-level to prevent conflicts. project-m36Returns True iff a projection scalar expr within a larger expression. Used for group by aggregation validation.U Safe-Inferred" project-m36Recurse relvars references and transaction parents to extract a subset of relevant transactions. probably could do some trimming of transactions that are not referenced by relvars, but that is rare, so probably of not much benefit should be trim merge parents that don't contribute to the relvars? maybeV Safe-Inferred";?D  project-m36/Apply SchemaIsomorphs to database context data. project-m36Return 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 constraint project-m36Relation variables names represented in the virtual schema space. Useful for determining if a relvar name is valid in the schema. project-m36Check that all mentioned relvars are actually present in the current schema. project-m36If the database context expression adds or removes a relvar, we need to update the isomorphs to create a passthrough Isomorph. project-m36Morph a relational expression in one schema to another isomorphic schema. Returns a function which can be used to morph a . Here, we naively apply the morphs in the current context ignoring past contexts because: * the current schema may not exist in past * this function should only be used for showing DDL, not for expression evaluation. * if a schema were renamed, then the path to past isomorphisms in the transaction graph tree would be lost. project-m36Apply the isomorphism transformations to the relational expression to convert the relational expression from operating on one schema to a disparate, isomorphic schema. project-m36Show metadata about the relation variables in the isomorphic schema. project-m36Create inclusion dependencies mainly for IsoRestrict because the predicate should hold in the base schema. project-m36The names of inclusion dependencies might leak context about a different schema, but that's arbitrary and cannot be altered without having the user provide a renaming function or a new set of incDep names- seems extraneous.W Safe-Inferred "5?X Safe-Inferred"Y Safe-Inferred "m project-m36Hash a transaction within its graph context to create a Merkle hash for it. project-m36Return a hash of just DDL-specific (schema) attributes. This is useful for determining if a client has the appropriate updates needed to work with the current schema.  Z Safe-Inferred";?Ż project-m36Operators which manipulate a transaction graph and which transaction the current Session is based upon. project-m367Used for git-style head backtracking such as topic~3^2. project-m36git equivalent of ~v: walk back n parents, arbitrarily choosing a parent when a choice must be made project-m36git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent project-m36git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp project-m368Record a lookup for a specific transaction in the graph. project-m36*Create a transaction graph from a context. project-m369A root transaction terminates a graph and has no parents. project-m36Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph project-m36Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple. project-m36Search from a past graph point to all following heads for a specific transaction. If found, return the transaction path, otherwise a RelationalError. project-m36After splicing out a subgraph, run it through this function to remove references to transactions which are not in the subgraph. project-m36Create a temporary branch for commit, merge the result to head, delete the temporary branch. This is useful to atomically commit a transaction, avoiding a TransactionIsNotHeadError but trading it for a potential MergeError. this is not a GraphOp because it combines multiple graph operations project-m368Ensure that referenced transactions remain in the graph.==[ Safe-Inferred"\ Safe-Inferred" project-m36The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).] Safe-Inferred" project-m36?A temporary function to be replaced by IO-based implementation. project-m36optimize relational expression within database context expr monad**^ Safe-Inferred"} project-m36Returns the notifications which should be triggered based on the transition from the first  to the second ._ Safe-Inferred";?Q project-m36The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.` Safe-Inferred"̕a Safe-Inferred"` project-m36Return a hash of just DDL-specific (schema) attributes. This is useful for determining if a client has the appropriate updates needed to work with the current schema. project-m36Process all relations within the context of the transaction graph to extract the relation variables types. project-m36Return a Relation which represents the database context's current DDL schema. Safe-Inferred ";?* project-m364There are several reasons why a connection can fail. project-m36"When a notification is fired, the ; is evaluated in the commit's pre-change context while the  is evaluated in the post-change context and they are returned along with the original notification. project-m36Used for callbacks from the server when monitored changes have been made. project-m36 Construct a  to describe how to make the . The database can be run within the current process or running remotely via RPC. project-m36The 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. project-m366The empty notification callback ignores all callbacks. project-m36>Use this for connecting to remote servers on the default port. project-m36Use this for connecting to remote servers with the default database name. project-m36Use this for connecting to remote servers with the default head name. project-m365Use this for connecting to the default remote server. project-m36Create 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. project-m36Resolve a server address using DNS, if necessary. The caller is expected to set any necessary socket options afterwards. project-m36 To create a ) to a remote or local database, create a  and call . project-m36Create a new session at the transaction id and return the session's Id. project-m36Call  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. project-m36Discards a session, eliminating any uncommitted changes present in the session. project-m36 cleans up the database access connection and closes any relevant sockets. project-m36=Returns the name of the currently selected isomorphic schema. project-m36&Switch to the named isomorphic schema. project-m36Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database. project-m36Execute 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. project-m36Similar to a git rebase,  atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the > and commits the merge. This is useful to reduce incidents of  s but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead. project-m36Execute a database context IO-monad-based expression for the given session and connection. s modify the DatabaseContext but cannot be purely implemented. this is almost completely identical to executeDatabaseContextExpr above project-m36Execute a transaction graph expression in the context of the session and connection. Transaction graph operators modify the transaction graph state. project-m36A trans-graph expression is a relational query executed against the entirety of a transaction graph. project-m36Schema expressions manipulate the isomorphic schemas for the current . project-m36After 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. project-m36(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. project-m36Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk. project-m36Return 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. project-m36 Return a Map of the database's constraints at the context of the session and connection. project-m36Return 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. project-m36Return 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 transaction project-m36Returns the names and types of the relation variables in the current  . project-m36Returns a relation representing the complete DDL of the current . project-m36Returns the names and types of the atom functions in the current  . project-m36Returns the transaction id for the connection's disconnected transaction committed parent transaction.  project-m36Returns Just the name of the head of the current disconnected transaction or Nothing.  project-m36.Returns a listing of all available atom types. project-m36Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error. project-m36Calculate a hash on the DDL of the current database context (not the graph). This is useful for validating on the client that the database schema meets the client's expectation. Any DDL change will change this hash. This hash does not change based on the current isomorphic schema being examined. This function is not affected by the current schema (since they are all isomorphic anyway, they should return the same hash). project-m36Convert a SQL Query expression into a DataFrameExpr. Because the conversion process requires substantial database metadata access (such as retrieving types for various subexpressions), we cannot process SQL client-side. However, the underlying DBMS is completely unaware that the resultant DataFrameExpr has come from SQL.DEFGJKNOPQRTUVWX[\]^_`jklmnopq  UVWXDEFG  T PQR[\]^_`   NOJKjklmnopqb Safe-Inferred" project-m36Returns a relation which lists the names of relvars in the current session as well as its types. $$c Safe-Inferred"Ld Safe-Inferred"e Safe-Inferred" project-m36A notification callback which logs the notification to stderr and does nothing else. project-m36A 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.f Safe-Inferred"}  project-m36A union of connection and other errors that can be returned from . project-m36A simple alternative to connectProjectM36* which includes simple session management. project-m36Same as  but always connects to the master branch. project-m36Closes the database connection. project-m36Runs a Db monad which may include some database updates. If an exception or error occurs, the transaction is rolled back. Otherwise, the transaction is committed to the head of the current branch. project-m36Same as 1 except that the merge strategy can be specified. project-m36 Execute a  in the DB monad. Database context expressions manipulate the state of the database. In case of an error, the transaction is terminated and the connection's session is rolled back. project-m36Run a  query in the DB monad. Relational expressions perform read-only queries against the current database state. project-m36Run a  update expression. If there is an error, just return it without cancelling the current transaction. project-m36Run a  query expression. If there is an error, just return it without cancelling the transaction. project-m36Unconditionally roll back the current transaction and throw an exception to terminate the execution of the Db monad. project-m36>Cancel a transaction and carry some error information with it. project-m36 Converts the  result from a 6 action into an immediate cancel in the case of error.UVWX     UVWXijklmnopqrstuvwxyz{|}~                                                                                                                              p                                                                                                     ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! " # $ $ $ $ $ $$$$ $$ $ % & & & & & & &&& & & ' (( ))* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + + + + + + + + + + , , - - - - - - - - - - - - - - - - - - - - - - - - - - - . . . . . . / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 3333 3 3 3 3 3 3 44444 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 9 9 : : : : : : : : : : ; ; ; ; ; ; < < < < < < < < < < = = = = = = = = = = > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ? ? ? @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B B B B B B                                            C C C C C C C C C C CCCCC CCCCCC C CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDEEEEEEEEEEEEFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHIJJJJKKKKKKKLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNN NNNNNNNNNNNNNNNN NNNNNNNNNNN N N NNNNNNNNNNNNNNNNNNNOOOOOOPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^____________________________________________________________________________________________________________________________________________``aaa  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccddddddddddddddddddeeeeeeeeeeeeeeeeffffffffffffffffffffffffff iproject-m36-1.1.1-inplaceProjectM36.Tupleable.DerivingProjectM36.ClientProjectM36.AtomFunctionError'ProjectM36.DatabaseContextFunctionErrorProjectM36.FSTypeProjectM36.FileLockProjectM36.MerkleHashProjectM36.Base!ProjectM36.GraphRefRelationalExprProjectM36.FunctionalDependency"ProjectM36.DisconnectedTransactionProjectM36.DataTypes.SortingProjectM36.DataTypes.PrimitiveProjectM36.DataTypes.MaybeProjectM36.DataTypes.List!ProjectM36.DataTypes.NonEmptyListProjectM36.DataConstructorDefProjectM36.AttributeNamesProjectM36.AtomFunctionBodyProjectM36.DataTypes.DayProjectM36.DataTypes.DateTimeProjectM36.DataTypes.ByteStringProjectM36.MiscUtilsProjectM36.NormalizeExprProjectM36.PersistProjectM36.SQL.SelectProjectM36.SQL.DropTableProjectM36.SQL.DeleteProjectM36.SQL.CreateTableProjectM36.ErrorProjectM36.AttributeProjectM36.AttributeExprProjectM36.ScriptSession&ProjectM36.Serialise.AtomFunctionError1ProjectM36.Serialise.DatabaseContextFunctionErrorProjectM36.SessionProjectM36.TraceProjectM36.TransactionProjectM36.TransactionInfoProjectM36.TypeConstructorProjectM36.TypeConstructorDefProjectM36.AtomTypeProjectM36.DataTypes.IntervalProjectM36.AtomProjectM36.TupleProjectM36.TupleSetProjectM36.RelationProjectM36.SessionsProjectM36.Serialise.BaseProjectM36.Serialise.ErrorProjectM36.SQL.UpdateProjectM36.SQL.InsertProjectM36.SQL.DBUpdateProjectM36.FunctionProjectM36.Relation.Parse.CSVProjectM36.KeyProjectM36.InclusionDependency"ProjectM36.DatabaseContextFunctionProjectM36.Relation.Show.HTMLProjectM36.Relation.Show.CSVProjectM36.AtomFunctionProjectM36.DataTypes.SQL.NullProjectM36.DataTypes.EitherProjectM36.DataTypes.BasicProjectM36.AtomableProjectM36.TupleableProjectM36.Shortcuts"ProjectM36.AtomFunctions.Primitive ProjectM36.Relation.Show.GnuplotProjectM36.AtomFunctions.BasicProjectM36.Transaction.PersistProjectM36.DatabaseContextProjectM36.SQLDatabaseContextProjectM36.DateExamplesProjectM36.ArbitraryProjectM36.WCWidthProjectM36.Relation.Show.TermProjectM36.DataFrameProjectM36.Serialise.DataFrameProjectM36.WithNameExprProjectM36.RelationalExpression#ProjectM36.TransactionGraph.Persist!ProjectM36.TransactionGraph.MergeProjectM36.SQL.Convert#ProjectM36.ReferencedTransactionIdsProjectM36.IsomorphicSchema%ProjectM36.Serialise.IsomorphicSchemaProjectM36.RegisteredQueryProjectM36.HashSecurelyProjectM36.TransactionGraph ProjectM36.TransactionGraph.Show)ProjectM36.TransGraphRelationalExpressionProjectM36.StaticOptimizerProjectM36.Notifications!ProjectM36.Server.RemoteCallTypes'ProjectM36.DatabaseContextFunctionUtilsProjectM36.DDLTypeProjectM36.Server.EntryPointsProjectM36.Server.ConfigProjectM36.Server.ParseArgsProjectM36.ServerProjectM36.Client.SimpleDataProxybase GHC.GenericsGenericnetwork-3.2.7.0-aa67bdbb9b1030c1e37c149aff9b66d8bdc046b32a276211bddb028f128faf29Network.Socket.Info ServiceNameAtomFunctionErrorAtomFunctionUserErrorAtomFunctionTypeMismatchErrorAtomFunctionParseErrorInvalidIntervalOrderingErrorInvalidIntervalBoundariesError&AtomFunctionAttributeNameNotFoundErrorInvalidIntBoundErrorInvalidUUIDStringRelationAtomExpectedErrorAtomFunctionEmptyRelationError#AtomTypeDoesNotSupportOrderingError#AtomTypeDoesNotSupportIntervalErrorAtomFunctionBytesDecodingError$fGenericAtomFunctionError$fEqAtomFunctionError$fShowAtomFunctionError$fNFDataAtomFunctionErrorDatabaseContextFunctionError DatabaseContextFunctionUserError%$fGenericDatabaseContextFunctionError $fEqDatabaseContextFunctionError"$fShowDatabaseContextFunctionError$$fNFDataDatabaseContextFunctionErrorCFSTypeCStatFSc_statfssizeofStructStatFSfsTypeSupportsJournalingLockTypeReadLock WriteLockLockFile lockStruct openLockFile closeLockFilelockFile unlockFile$fShowLockType MerkleHash _unMerkleHash$fShowMerkleHash$fEqMerkleHash$fGenericMerkleHash$fMonoidMerkleHash$fSemigroupMerkleHash$fNFDataMerkleHashDatabaseContextFunctionBodyDatabaseContextFunctionAtomFunctionBody AtomFunction FunctionBodyFunctionScriptBodyFunctionBuiltInBodyFunctionObjectLoadedBodyFunctionfuncNamefuncTypefuncBodyFunctionBodyScript FunctionNameDatabaseContextFunctionsDatabaseContextFunctionBodyType MergeStrategyUnionMergeStrategyUnionPreferMergeStrategySelectedBranchMergeStrategy TupleExprsGraphRefTupleExprsTupleExprsBaseGraphRefTupleExpr TupleExpr TupleExprBaseAttributeExprBaseAttributeAndTypeNameExprNakedAttributeExprGraphRefAttributeExpr AttributeExprPersistenceStrategy NoPersistenceMinimalPersistenceCrashSafePersistenceGraphRefAttributeNamesAttributeNamesAttributeNamesBaseInvertedAttributeNamesUnionAttributeNamesIntersectAttributeNamesRelationalExprAttributeNamesObjectModuleNameObjectFilePathObjectFileEntryFunctionNameAtomFunctionBodyType AtomFunctionsGraphRefExtendTupleExprExtendTupleExprExtendTupleExprBaseAttributeExtendTupleExpr AtomExprBaseAttributeAtomExprSubrelationAttributeAtomExpr NakedAtomExprFunctionAtomExprRelationAtomExprIfThenAtomExprConstructedAtomExprAggAtomFuncExprInfoGraphRefAtomExprAtomExprTransactionDiffExpr DirtyFlagDisconnectedTransaction Transaction TransactionIdTransactionParentsTransactionInfoparentsstamp merkleHashTransactionGraphTransactionHeadsHeadNameRestrictionPredicateExprBase TruePredicate AndPredicate OrPredicate NotPredicateRelationalExprPredicateAtomExprPredicateAttributeEqualityPredicate GraphRefRestrictionPredicateExprRestrictionPredicateExprDatabaseContextIOExprGraphRefDatabaseContextIOExprDatabaseContextIOExprBaseAddAtomFunctionLoadAtomFunctionsAddDatabaseContextFunctionLoadDatabaseContextFunctionsCreateArbitraryRelationRangeObjFunctionName ObjModuleNameDatabaseContextExprBase NoOperationDefineUndefineAssignInsertDeleteUpdateAddInclusionDependencyRemoveInclusionDependencyAddNotificationRemoveNotificationAddTypeConstructorRemoveTypeConstructorRemoveAtomFunctionRemoveDatabaseContextFunctionExecuteDatabaseContextFunctionAddRegisteredQueryRemoveRegisteredQuery MultipleExprGraphRefDatabaseContextExprDatabaseContextExprDatabaseContextExprNameAttributeNameAtomExprMapInclusionDependency IncDepNameDatabaseContextinclusionDependenciesrelationVariables atomFunctions dbcFunctions notificationstypeConstructorMappingregisteredQueriesRegisteredQueriesRegisteredQueryNameSchemaIsomorphsSchemaIsomorph IsoRestrict IsoRenameIsoUnionSchemaSchemas Subschemas SchemaNameGraphRefRelationalExprGraphRefTransactionMarkerTransactionMarkerUncommittedContextMarkerRelationVariablesInclusionDependenciesDataConstructorDefArg$DataConstructorDefTypeConstructorArg DataConstructorDefTypeVarNameArgDataConstructorDefsDataConstructorDef AtomTypeNameDataConstructorNameTypeConstructorArgNameTypeConstructorNameTypeConstructorMappingTypeConstructorBaseADTypeConstructorPrimitiveTypeConstructorRelationAtomTypeConstructor TypeVariableTypeConstructorTypeConstructorDefADTypeConstructorDefPrimitiveTypeConstructorDef TypeVarNameNotificationExpressionNotificationChangeExpressionNotificationReportOldExpressionNotificationReportNewExpression Notification changeExpr reportOldExpr reportNewExpr NotificationsNotificationNameGraphRefWithNameExpr WithNameExprWithNameExprBaseGraphRefWithNameAssocsWithNamesAssocsBaseWithNamesAssocsRelationalExprBaseMakeRelationFromExprsMakeStaticRelationExistingRelationRelationVariableRelationValuedAttributeProjectUnionJoinRename DifferenceGroupUngroupRestrictEquals NotEqualsExtendWithRelationalExpr RelVarNameRelationCardinality CountableFiniteRelation RelationTupleRelationTupleSetasList Attributes attributesVecAttributesHash Attribute AttributeName TypeVarMapAtomType IntAtomTypeIntegerAtomTypeScientificAtomTypeDoubleAtomType TextAtomType DayAtomTypeDateTimeAtomTypeByteStringAtomType BoolAtomType UUIDAtomTypeRelationAtomTypeSubrelationFoldAtomTypeConstructedAtomTypeRelationalExprAtomTypeTypeVariableTypeAtom IntegerAtomIntAtomScientificAtom DoubleAtomTextAtomDayAtom DateTimeAtomByteStringAtomBoolAtomUUIDAtom RelationAtomRelationalExprAtomSubrelationFoldAtomConstructedAtom DatabaseName StringTypeisRelationAtomType!attributesContainRelationAtomType attributesSetsortedAttributesIndicestransactionHeadsForGraphtransactionsForGraphtransactionIdsForGraph transactionIdtransactionInfopersistenceDirectory attrTypeVarstypeVarsattrExprTypeVars atomTypeVars unimplemented$fHashableDiffTime$fHashableUTCTime $fHashableDay$fEqAttributes$fShowAttributes$fHashableAttribute$fHashableRelationalExprBase$fHashableRelation$fNFDataRelation $fEqRelation$fNFDataRelationTuple$fEqRelationTuple$fHashableRelationTuple$fNFDataRelationTupleSet$fEqRelationTupleSet$fReadRelation$fHashableRelationTupleSet$fHashableAtom$fHashableTupleExprsBase$fHashableTupleExprBase$fHashableExtendTupleExprBase$fHashableAtomExprBase&$fHashableRestrictionPredicateExprBase$fHashableAttributeNamesBase!$fHashableDatabaseContextExprBase$fNFDataFunctionBody$fHashableFunction $fEqFunction$fOrdTransaction$fEqTransaction$fGenericTransactionGraph$fGenericTransaction$fGenericSchemas$fNFDataDatabaseContext$fGenericDatabaseContext$fGenericFunction$fNFDataFunction$fGenericFunctionBody$fShowDatabaseContextIOExprBase$fEqDatabaseContextIOExprBase"$fGenericDatabaseContextIOExprBase$fShowDatabaseContextExprBase$fReadDatabaseContextExprBase$fEqDatabaseContextExprBase $fGenericDatabaseContextExprBase$fNFDataDatabaseContextExprBase$fShowNotification$fEqNotification$fGenericNotification$fNFDataNotification$fShowInclusionDependency$fEqInclusionDependency$fGenericInclusionDependency$fNFDataInclusionDependency$fHashableInclusionDependency$fReadInclusionDependency$fGenericSchema$fGenericSchemaIsomorph$fShowSchemaIsomorph$fEqAtomExprBase$fShowAtomExprBase$fReadAtomExprBase$fGenericAtomExprBase$fNFDataAtomExprBase$fFoldableAtomExprBase$fFunctorAtomExprBase$fTraversableAtomExprBase$fShowRelationalExprBase$fReadRelationalExprBase$fEqRelationalExprBase$fGenericRelationalExprBase$fNFDataRelationalExprBase$fFoldableRelationalExprBase$fFunctorRelationalExprBase$fTraversableRelationalExprBase$fEqTupleExprsBase$fShowTupleExprsBase$fReadTupleExprsBase$fGenericTupleExprsBase$fNFDataTupleExprsBase$fFoldableTupleExprsBase$fFunctorTupleExprsBase$fTraversableTupleExprsBase$fEqTupleExprBase$fShowTupleExprBase$fReadTupleExprBase$fGenericTupleExprBase$fNFDataTupleExprBase$fFoldableTupleExprBase$fFunctorTupleExprBase$fTraversableTupleExprBase$fEqAttributeNamesBase$fShowAttributeNamesBase$fReadAttributeNamesBase$fGenericAttributeNamesBase$fNFDataAttributeNamesBase$fFoldableAttributeNamesBase$fFunctorAttributeNamesBase$fTraversableAttributeNamesBase$fShowExtendTupleExprBase$fReadExtendTupleExprBase$fEqExtendTupleExprBase$fGenericExtendTupleExprBase$fNFDataExtendTupleExprBase$fFoldableExtendTupleExprBase$fFunctorExtendTupleExprBase $fTraversableExtendTupleExprBase"$fShowRestrictionPredicateExprBase"$fReadRestrictionPredicateExprBase $fEqRestrictionPredicateExprBase%$fGenericRestrictionPredicateExprBase$$fNFDataRestrictionPredicateExprBase&$fFoldableRestrictionPredicateExprBase%$fFunctorRestrictionPredicateExprBase)$fTraversableRestrictionPredicateExprBase$fShowRelation$fGenericRelation$fShowRelationTupleSet$fGenericRelationTupleSet$fReadRelationTupleSet$fShowRelationTuple$fReadRelationTuple$fGenericRelationTuple$fEqAtom $fShowAtom $fNFDataAtom $fGenericAtom $fReadAtom$fEqMergeStrategy$fShowMergeStrategy$fGenericMergeStrategy$fNFDataMergeStrategy$fEqDataConstructorDef$fShowDataConstructorDef$fGenericDataConstructorDef$fNFDataDataConstructorDef$fHashableDataConstructorDef$fReadDataConstructorDef$fShowDataConstructorDefArg$fGenericDataConstructorDefArg$fEqDataConstructorDefArg$fNFDataDataConstructorDefArg$fHashableDataConstructorDefArg$fReadDataConstructorDefArg$fEqAttributeExprBase$fShowAttributeExprBase$fReadAttributeExprBase$fGenericAttributeExprBase$fNFDataAttributeExprBase$fFoldableAttributeExprBase$fFunctorAttributeExprBase$fTraversableAttributeExprBase$fHashableAttributeExprBase$fShowTypeConstructorBase$fGenericTypeConstructorBase$fEqTypeConstructorBase$fNFDataTypeConstructorBase$fHashableTypeConstructorBase$fReadTypeConstructorBase$fShowPersistenceStrategy$fReadPersistenceStrategy$fEqGraphRefTransactionMarker$fShowGraphRefTransactionMarker"$fGenericGraphRefTransactionMarker!$fNFDataGraphRefTransactionMarker$fOrdGraphRefTransactionMarker$fShowTransactionInfo$fGenericTransactionInfo$fShowTypeConstructorDef$fGenericTypeConstructorDef$fEqTypeConstructorDef$fNFDataTypeConstructorDef$fHashableTypeConstructorDef$fReadTypeConstructorDef $fEqAtomType$fNFDataAtomType$fGenericAtomType$fShowAtomType$fReadAtomType$fHashableAtomType$fNFDataAttributes$fReadAttributes$fHashableAttributes$fGenericAttributes $fEqAttribute$fShowAttribute$fReadAttribute$fGenericAttribute$fNFDataAttribute$fShowNotificationExpression$fEqNotificationExpression$fGenericNotificationExpression$fNFDataNotificationExpression$fShowWithNameExprBase$fReadWithNameExprBase$fEqWithNameExprBase$fGenericWithNameExprBase$fNFDataWithNameExprBase$fFoldableWithNameExprBase$fFunctorWithNameExprBase$fTraversableWithNameExprBase$fHashableWithNameExprBase$fEqRelationCardinality$fShowRelationCardinality$fGenericRelationCardinality$fOrdRelationCardinalityRelationalExprBaseFMakeRelationFromExprsFMakeStaticRelationFExistingRelationFRelationVariableFRelationValuedAttributeFProjectFUnionFJoinFRenameF DifferenceFGroupFUngroupF RestrictFEqualsF NotEqualsFExtendFWithF$fCorecursiveRelationalExprBase$fRecursiveRelationalExprBase$fFunctorRelationalExprBaseF$fFoldableRelationalExprBaseF $fTraversableRelationalExprBaseFSingularTransactionRefMultipleTransactionsRefNoTransactionsRefsingularTransactioninSameTransactionsingularTransactions$fMonoidSingularTransactionRef!$fSemigroupSingularTransactionRef$fEqSingularTransactionRef$fShowSingularTransactionRefFunctionalDependency,inclusionDependenciesForFunctionalDependencyconcreteDatabaseContextschemasloadGraphRefRelVarsOnlyparentIdisDirtyfreshTransaction compareAtomsisSortableAtomTypeprimitiveTypeConstructorMappingintTypeConstructordoubleTypeConstructortextTypeConstructordayTypeConstructordateTimeTypeConstructoruUIDTypeConstructoratomTypeForAtom maybeAtomTypemaybeTypeConstructorMappingmaybeAtomFunctions listAtomTypelistTypeConstructorMapping listLength listMaybeHeadlistAtomFunctionslistConsnonEmptyListAtomType"nonEmptyListTypeConstructorMappingnonEmptyListLengthnonEmptyListHeadnonEmptyListAtomFunctionsemptyDataConstructornamefieldstypeVarsInDefArgemptyallsomecompiledAtomFunctionBodydayAtomFunctionsdateTimeAtomFunctionsbytestringAtomFunctionsdupesindexedCurrentTransactionId ProcessExprMrunProcessExprM askMarkerprocessRelationalExprprocessWithNameExprprocessAttributeNamesprocessDatabaseContextExprprocessDatabaseContextIOExprprocessRestrictionPredicateExprprocessExtendTupleExprprocessAtomExprprocessTupleExprsprocessTupleExprprocessAttributeExprDiskSync NoDiskSync FsyncDiskSync writeFileSync renameSyncwriteSerialiseSync printFdCount TableExpr fromClause whereClause groupByClause havingClause orderByClause limitClause offsetClauseRestrictionExpr DistinctnessDistinctAllFuncName TableAlias unTableAlias ColumnAlias unColumnAlias OperatorName TableNameUnqualifiedColumnName ColumnNameProjectionNameAsteriskColumnProjectionNameJoinOnCondition JoinConditionJoinOn JoinUsingJoinType InnerJoinRightOuterJoin LeftOuterJoin FullOuterJoin CrossJoin NaturalJoin NullsOrder NullsFirst NullsLast Direction Ascending DescendingSortExpr HavingExpr GroupByExprInPredicateValueInList InQueryExpr InScalarExprBoolOpAndOpOrOpScalarExprBaseIntegerLiteral DoubleLiteral StringLiteralBooleanLiteral NullLiteral IdentifierBinaryOperatorPrefixOperatorPostfixOperatorBetweenOperatorFunctionApplicationCaseExprQuantifiedComparisonInExprBooleanOperatorExpr ExistsExpr caseWhenscaseElseqcExpr qcOperator qcPredicateqcQuery ScalarExprProjectionScalarExprTableRefSimpleTableRefInnerJoinTableRefRightOuterJoinTableRefLeftOuterJoinTableRefFullOuterJoinTableRefCrossJoinTableRefNaturalJoinTableRefAliasedTableRef QueryTableRefQuantifiedComparisonPredicateQCAnyQCSomeQCAllComparisonOperatorOpLTOpGTOpGTEOpEQOpNEOpLTEInFlagInNotIn WithExprAliasWithExpr WithClause isRecursive withExprs SelectItemSelect distinctnessprojectionClause tableExpr withClause QueryOperatorUnionQueryOperatorIntersectQueryOperatorExceptQueryOperatorQuery QuerySelect QueryValues QueryTableQueryOp emptySelectemptyTableExpr$fHashableComparisonOperator'$fHashableQuantifiedComparisonPredicate$fHashableOperatorName$fHashableFuncName$fHashableDistinctness$fHashableScalarExprBase$fHashableSelect $fShowQuery $fEqQuery$fGenericQuery $fNFDataQuery$fSerialiseQuery$fShowTableExpr $fEqTableExpr$fGenericTableExpr$fNFDataTableExpr$fSerialiseTableExpr$fHashableTableExpr$fShowRestrictionExpr$fEqRestrictionExpr$fGenericRestrictionExpr$fSerialiseRestrictionExpr$fNFDataRestrictionExpr$fHashableRestrictionExpr$fShowScalarExprBase$fEqScalarExprBase$fGenericScalarExprBase$fNFDataScalarExprBase$fEqInPredicateValue$fShowInPredicateValue$fGenericInPredicateValue$fNFDataInPredicateValue$fSerialiseInPredicateValue$fHashableInPredicateValue $fShowSelect $fEqSelect$fGenericSelect$fNFDataSelect$fSerialiseSelect$fShowWithClause$fEqWithClause$fGenericWithClause$fNFDataWithClause$fSerialiseWithClause$fHashableWithClause$fShowWithExpr $fEqWithExpr$fGenericWithExpr$fNFDataWithExpr$fSerialiseWithExpr$fHashableWithExpr$fShowSortExpr $fEqSortExpr$fGenericSortExpr$fNFDataSortExpr$fSerialiseSortExpr$fHashableSortExpr$fShowHavingExpr$fEqHavingExpr$fGenericHavingExpr$fSerialiseHavingExpr$fHashableHavingExpr$fNFDataHavingExpr$fShowGroupByExpr$fEqGroupByExpr$fGenericGroupByExpr$fSerialiseGroupByExpr$fHashableGroupByExpr$fNFDataGroupByExpr$fShowTableRef $fEqTableRef$fGenericTableRef$fNFDataTableRef$fSerialiseTableRef$fHashableTableRef$fShowJoinCondition$fEqJoinCondition$fGenericJoinCondition$fNFDataJoinCondition$fSerialiseJoinCondition$fHashableJoinCondition$fShowJoinOnCondition$fEqJoinOnCondition$fGenericJoinOnCondition$fSerialiseJoinOnCondition$fNFDataJoinOnCondition$fHashableJoinOnCondition$fShowDistinctness$fEqDistinctness$fGenericDistinctness$fNFDataDistinctness$fSerialiseDistinctness$fShowFuncName $fEqFuncName$fGenericFuncName $fOrdFuncName$fSerialiseFuncName$fNFDataFuncName$fShowTableAlias$fEqTableAlias$fOrdTableAlias$fGenericTableAlias$fSerialiseTableAlias$fMonoidTableAlias$fSemigroupTableAlias$fNFDataTableAlias$fHashableTableAlias$fShowColumnAlias$fEqColumnAlias$fOrdColumnAlias$fGenericColumnAlias$fSerialiseColumnAlias$fNFDataColumnAlias$fHashableColumnAlias$fShowOperatorName$fEqOperatorName$fOrdOperatorName$fGenericOperatorName$fSerialiseOperatorName$fNFDataOperatorName$fShowTableName $fEqTableName$fOrdTableName$fGenericTableName$fSerialiseTableName$fHashableTableName$fNFDataTableName$fShowUnqualifiedColumnName$fEqUnqualifiedColumnName$fOrdUnqualifiedColumnName$fGenericUnqualifiedColumnName $fSerialiseUnqualifiedColumnName$fHashableUnqualifiedColumnName$fNFDataUnqualifiedColumnName$fShowColumnName$fEqColumnName$fOrdColumnName$fGenericColumnName$fSerialiseColumnName$fHashableColumnName$fNFDataColumnName$fShowColumnProjectionName$fEqColumnProjectionName$fOrdColumnProjectionName$fGenericColumnProjectionName$fSerialiseColumnProjectionName$fNFDataColumnProjectionName$fHashableColumnProjectionName$fShowProjectionName$fEqProjectionName$fOrdProjectionName$fGenericProjectionName$fNFDataProjectionName$fSerialiseProjectionName$fHashableProjectionName$fShowJoinType $fEqJoinType$fGenericJoinType$fNFDataJoinType$fSerialiseJoinType$fShowNullsOrder$fEqNullsOrder$fGenericNullsOrder$fNFDataNullsOrder$fSerialiseNullsOrder$fHashableNullsOrder$fShowDirection $fEqDirection$fGenericDirection$fNFDataDirection$fSerialiseDirection$fHashableDirection $fEqBoolOp $fShowBoolOp$fGenericBoolOp$fNFDataBoolOp$fSerialiseBoolOp$fHashableBoolOp#$fShowQuantifiedComparisonPredicate!$fEqQuantifiedComparisonPredicate&$fGenericQuantifiedComparisonPredicate%$fNFDataQuantifiedComparisonPredicate($fSerialiseQuantifiedComparisonPredicate$fShowComparisonOperator$fEqComparisonOperator$fGenericComparisonOperator$fNFDataComparisonOperator$fSerialiseComparisonOperator $fShowInFlag $fEqInFlag$fGenericInFlag$fNFDataInFlag$fSerialiseInFlag$fHashableInFlag$fShowWithExprAlias$fEqWithExprAlias$fGenericWithExprAlias$fSerialiseWithExprAlias$fNFDataWithExprAlias$fHashableWithExprAlias$fShowQueryOperator$fEqQueryOperator$fGenericQueryOperator$fNFDataQueryOperator$fSerialiseQueryOperator$fSerialiseScalarExprBase$fSerialiseScalarExprBase0ScalarExprBaseFIntegerLiteralFDoubleLiteralFStringLiteralFBooleanLiteralF NullLiteralF IdentifierFBinaryOperatorFPrefixOperatorFPostfixOperatorFBetweenOperatorFFunctionApplicationF CaseExprFQuantifiedComparisonFInExprFBooleanOperatorExprF ExistsExprF caseWhensF caseElseFqcExprF qcOperatorF qcPredicateFqcQueryF$fCorecursiveScalarExprBase$fRecursiveScalarExprBase$fFunctorScalarExprBaseF$fFoldableScalarExprBaseF$fTraversableScalarExprBaseF DropTabletarget$fShowDropTable $fEqDropTable$fGenericDropTable$fNFDataDropTable$fSerialiseDropTable restriction $fShowDelete $fEqDelete$fGenericDelete$fNFDataDelete$fSerialiseDeletePerColumnConstraintsnotNullConstraintuniquenessConstraint references ColumnTypeIntegerColumnTypeTextColumnTypeBoolColumnTypeDoubleColumnTypeDateTimeColumnTypeDateColumnTypeByteaColumnType CreateTable targetColumns$fShowCreateTable$fEqCreateTable$fGenericCreateTable$fNFDataCreateTable$fSerialiseCreateTable$fShowPerColumnConstraints$fEqPerColumnConstraints$fGenericPerColumnConstraints$fNFDataPerColumnConstraints$fSerialisePerColumnConstraints$fShowColumnType$fEqColumnType$fGenericColumnType$fNFDataColumnType$fSerialiseColumnTypeSQLErrorNotSupportedErrorTypeMismatchErrorNoSuchSQLFunctionErrorNoSuchSQLOperatorErrorDuplicateTableReferenceErrorMissingTableReferenceErrorTableAliasMismatchErrorUnexpectedTableNameErrorUnexpectedColumnNameErrorColumnNamesMismatchColumnResolutionErrorColumnAliasResolutionErrorUnexpectedRelationalExprErrorUnexpectedAsteriskErrorUnexpectedColumnProjectionNameAmbiguousColumnResolutionErrorDuplicateColumnAliasErrorAggregateGroupByMismatchError(GroupByColumnNotReferencedInGroupByError!UnsupportedGroupByProjectionErrorQueryOperatorTypeMismatchErrorSQLRelationalError ImportError'InvalidSHA256ErrorSHA256MismatchErrorInvalidFileURIErrorImportFileDecodeErrorImportFileErrorImportDownloadError SchemaErrorRelVarReferencesMissingRelVarInReferencedMoreThanOnceRelVarOutReferencedMoreThanOnceScriptCompilationErrorTypeCheckCompilationErrorSyntaxErrorCompilationErrorScriptCompilationDisabledErrorOtherScriptCompilationError MergeErrorSelectedHeadMismatchMergeErrorPreferredHeadMissingMergeError$StrategyViolatesConstraintMergeErrorInvalidMergeStrategyError)DisconnectedTransactionNotAMergeHeadError#StrategyViolatesComponentMergeError*StrategyViolatesRelationVariableMergeError2StrategyWithoutPreferredBranchResolutionMergeError)StrategyViolatesTypeConstructorMergeError)StrategyViolatesRegisteredQueryMergeErrorPersistenceErrorInvalidDirectoryErrorMissingTransactionErrorWrongDatabaseFormatVersionErrorRelationalErrorNoSuchAttributeNamesError TupleAttributeCountMismatchErrorEmptyAttributesErrorDuplicateAttributeNamesErrorTupleAttributeTypeMismatchErrorAttributeCountMismatchErrorAttributeNamesMismatchErrorAttributeTypesMismatchErrorAttributeNameInUseError!AttributeIsNotRelationValuedErrorCouldNotInferAttributesRelVarNotDefinedErrorRelVarAlreadyDefinedErrorRelationTypeMismatchErrorInclusionDependencyCheckError!InclusionDependencyNameInUseError$InclusionDependencyNameNotInUseError ParseErrorPredicateExpressionError NoCommonTransactionAncestorErrorNoSuchTransactionErrorRootTransactionTraversalError$HeadNameSwitchingHeadProhibitedErrorNoSuchHeadNameErrorUnknownHeadError%NewTransactionMayNotHaveChildrenErrorParentCountTraversalError NewTransactionMissingParentErrorTransactionIsNotAHeadErrorTransactionGraphCycleErrorSessionIdInUseErrorNoSuchSessionErrorFailedToFindTransactionErrorTransactionIdInUseErrorNoSuchFunctionErrorNoSuchTypeConstructorNameTypeConstructorAtomTypeMismatchAtomTypeMismatchErrorTypeConstructorNameMismatch*AtomTypeTypeConstructorReconciliationErrorDataConstructorNameInUseError)DataConstructorUsesUndeclaredTypeVariableTypeConstructorTypeVarsMismatchTypeConstructorTypeVarMissing$TypeConstructorTypeVarsTypesMismatchDataConstructorTypeVarsMismatch'AtomFunctionTypeVariableResolutionError AtomFunctionTypeVariableMismatchIfThenExprExpectedBooleanErrorAtomTypeNameInUseError/IncompletelyDefinedAtomTypeWithConstructorErrorAtomTypeNameNotInUseErrorAttributeNotSortableErrorFunctionNameInUseErrorFunctionNameNotInUseErrorEmptyCommitError"FunctionArgumentCountMismatchError)ConstructedAtomArgumentCountMismatchErrorNoSuchDataConstructorErrorNoSuchTypeConstructorErrorInvalidAtomTypeNameAtomTypeNotSupportedAtomOperatorNotSupportedEmptyTuplesErrorAtomTypeCountErrorAtomFunctionTypeErrorPrecompiledFunctionRemoveError)RelationValuedAttributesNotSupportedErrorNotificationNameInUseErrorNotificationNameNotInUseErrorNotificationValidationError ImportError ExportErrorUnhandledExceptionErrorMergeTransactionError ScriptErrorLoadFunctionErrorSecurityLoadFunctionErrorDatabaseLoadErrorSubschemaNameInUseErrorSubschemaNameNotInUseErrorSchemaCreationErrorImproperDatabaseStateErrorNonConcreteSchemaPlanErrorNoUncommittedContextInEvalError'TupleExprsReferenceMultipleMarkersErrorMerkleHashValidationErrorRegisteredQueryValidationErrorRegisteredQueryNameInUseError RegisteredQueryNameNotInUseErrorSQLConversionErrorMultipleErrors someErrors!$fExceptionScriptCompilationError$fNFDataMergeError$fShowSQLError $fEqSQLError$fGenericSQLError$fNFDataSQLError$fShowRelationalError$fEqRelationalError$fGenericRelationalError$fNFDataRelationalError$fShowMergeError$fEqMergeError$fGenericMergeError$fShowImportError'$fEqImportError'$fGenericImportError'$fNFDataImportError'$fShowSchemaError$fEqSchemaError$fGenericSchemaError$fNFDataSchemaError$fShowScriptCompilationError$fEqScriptCompilationError$fGenericScriptCompilationError$fNFDataScriptCompilationError$fShowPersistenceError$fEqPersistenceError$fGenericPersistenceError$fNFDataPersistenceErrorarityemptyAttributesnull singletontoListattributesFromList attributeNameatomType atomTypes atomTypesList addAttributejoinAttributes addAttributesmemberdeleteAttributeNamedeleteAttributeNamesrenameAttributerenameAttributesrenameAttributes'atomTypeForAttributeNameattributeForNameisAttributeNameContainedprojectionAttributesForNamesattributesForNamesattributeNameSetattributeNamesattributeNamesListattributesContainedattributeNamesContainednonMatchingAttributeNameSetmatchingAttributeNameSetattributeNamesNotContainedorderedAttributesorderedAttributeNamesattributesDifferencevectorUniqueifyverifyAttributesdropattributesAndOrderEqualattributesEqualattributesAsMapunion intersection$fMonoidAttributes$fSemigroupAttributesModuleDirectoryObjectLoadModeLoadObjectFile LoadDLLFileLoadAutoObjectFileModNameLoadSymbolErrorSecurityLoadSymbolErrorScriptSessionErrorScriptSessionLoadErrorScriptingDisabled ScriptSessionhscEnvatomFunctionBodyTypedbcFunctionBodyTypeinitScriptSession addImportshowType mkTypeForName compileScripttypeCheckScript mangleSymbolloadFunctionFromDirectory loadFunctionprefixUnderscore$fShowScriptSessionError$fSerialiseAtomFunctionError'$fSerialiseDatabaseContextFunctionErrorSession SessionIddefaultSchemaNamedisconnectedTransaction subschemas schemaName setSchemaName traceBlock parentIds rootParent singleParent!filterTransactionInfoTransactions filterParentfilterTransactionfresh timestamp argumentsfindDataConstructor atomTypeForDataConstructorDefArgatomTypeForDataConstructorresolveDataConstructorTypeVars!resolveDataConstructorArgTypeVarsresolveTypeConstructorTypeVarsresolveAttributeExprTypeVarsvalidateTypeConstructorDefvalidateDataConstructorDefvalidateDataConstructorDefArgatomTypeForTypeConstructor"atomTypeForTypeConstructorValidateatomTypeForAttributeExpr!isValidAtomTypeForTypeConstructorfindTypeConstructorresolveAttributesresolveAtomTyperesolveAtomTypesInTypeVarMapresolveTypeInAtomresolveTypesInTuplevalidateAtomTypevalidateAttributesvalidateTypeVarMap validateTuple validateAtomatomTypeVerifytypeVarMapsVerifyprettyAtomTypeprettyAttributeresolveTypeVariablesresolveTypeVariableresolveFunctionReturnValue*resolvedAtomTypesForDataConstructorDefArgs(resolvedAtomTypeForDataConstructorDefArgisResolvedTypeisResolvedAttributesisResolvedAttributeanyRelationAtomType OpenIntervalintervalSubTypesupportsIntervalsupportsOrdering atomComparecreateIntervalintervalAtomTypeintervalAtomFunctionsisIntervalAtomTypeintervalOverlapsintervalTypeConstructorMappingrelationForAtom atomToText emptyTuple tupleSizetupleAttributeNameSettupleAttributes tupleAssocsorderedTupleAssocs tupleAtomsatomForAttributeNameatomsForAttributeNamesvectorIndicesForAttributeNamesrelationForAttributeNametupleRenameAttributemkRelationTuplemkRelationTuplesmkRelationTupleFromMapsingleTupleSetJoinsingleTupleJoin vectorUnion tupleExtendtupleAtomExtend tupleProjecttupleIntersectionupdateTupleWithAtoms tupleToMap verifyTuple reorderTuple trimTuple emptyTupleSetsingletonTupleSetverifyTupleSet mkTupleSetmkTupleSetFromList tupleSetUnionRestrictionFilter attributesatomTypeForNamemkRelationFromListemptyRelationWithAttrs mkRelationmkRelationDeferVerifyrelationWithEmptyTupleSetmkRelationFromTuples relationTrue relationFalsesingletonTupleproject renameManyrenamedegree cardinalitygroup restrictEqungroup tupleUngroupattributesForRelvalrestrictjoin differencerelMap relMogrifyrelFoldimageRelationFortypesAsRelationrandomizeTupleOrderoneTuple tuplesListSessions stmMapToList stmSetToListuuidAtomsessionsAsRelation SlimTupleSet fromWordsTupfromGregorianTup slimTupleSetfattenTupleSet$fSerialiseRelation$fSerialiseAttributes$fSerialiseDay$fSerialiseUUID$fSerialiseRelationTupleSet!$fSerialiseNotificationExpression$fSerialiseMergeStrategy$fSerialiseSchema$fSerialiseExtendTupleExprBase$fSerialiseAttributeNamesBase$fSerialiseTupleExprBase$fSerialiseTupleExprsBase$fSerialiseAttributeExprBase$fSerialiseMerkleHash$fSerialiseAtomExprBase$fSerialiseTransactionInfo'$fSerialiseRestrictionPredicateExprBase$$fSerialiseDatabaseContextIOExprBase"$fSerialiseDatabaseContextExprBase$fSerialiseInclusionDependency$fSerialiseSchemaIsomorph$$fSerialiseGraphRefTransactionMarker $fSerialiseDataConstructorDefArg$fSerialiseDataConstructorDef$fSerialiseTypeConstructorBase$fSerialiseTypeConstructorDef$fSerialiseNotification$fSerialiseWithNameExprBase$fSerialiseRelationalExprBase$fSerialiseRelationCardinality$fSerialiseRelationTuple$fSerialiseAttribute$fSerialiseAtomType$fSerialiseAtom$fSerialiseSQLError$fSerialiseImportError'$fSerialiseSchemaError$fSerialisePersistenceError!$fSerialiseScriptCompilationError$fSerialiseMergeError$fSerialiseRelationalError setColumns mRestriction $fShowUpdate $fEqUpdate$fGenericUpdate$fNFDataUpdate$fSerialiseUpdatesource $fShowInsert $fEqInsert$fGenericInsert$fNFDataInsert$fSerialiseInsertDBUpdate UpdateUpdate UpdateInsert UpdateDeleteUpdateCreateTableUpdateDropTable$fShowDBUpdate $fEqDBUpdate$fGenericDBUpdate$fNFDataDBUpdate$fSerialiseDBUpdatefunctionfunctionScriptprocessObjectLoadedFunctionBodyprocessObjectLoadedFunctions loadFunctionsfunctionForNameCsvImportError CsvParseErrorAttributeMappingErrorHeaderAttributeMismatchErrorcsvDecodeOptions csvAsRelation parseCSVAtomPcapitalizedIdentifiertakeToEndOfColumnDatatakeToEndOfIntervalBlockparens quotedString$fShowCsvImportErrorinclusionDependencyForKeydatabaseContextExprForUniqueKey databaseContextExprForForeignKey inclusionDependencyForForeignKeyisForeignKeyForinclusionDependenciesAsRelationinclusionDependencyForAtomExprexternalDatabaseContextFunctionemptyDatabaseContextFunctiondatabaseContextFunctionForNameevalDatabaseContextFunctionbasicDatabaseContextFunctions#precompiledDatabaseContextFunctions!isScriptedDatabaseContextFunction!databaseContextFunctionReturnType%createScriptedDatabaseContextFunction"databaseContextFunctionsAsRelationattributesAsHTMLrelationAsHTML writeHTMLwriteRel tupleAsHTMLtupleSetAsHTML RecordAtomunAtomRecordRelationTupleunTuple relationAsCSV#$fDefaultOrderedRecordRelationTuple$fToFieldRecordAtom"$fToNamedRecordRecordRelationTuplefoldAtomFuncTypeatomFunctionForNameemptyAtomFunctioncompiledAtomFunctionevalAtomFunctionextractAtomFunctionTypeisScriptedAtomFunctioncreateScriptedAtomFunctionatomFunctionsAsRelationexternalAtomFunction nullAtomTypenullTypeConstructorMappingnullAtomFunctionssqlCompareFunctions maybeFromAtom coalesceBool isSQLBoolsqlBoolnullAndnullOrnullAtom isNullOrTypeisNullisNullAtomTypeatomTypeFromSQLNullsqlIntegerBinaryFunctionsqlIntegerUnaryFunctionsqlCountsqlAbssqlMaxsqlMinsqlSum sqlIntegerAggsqlNullableIntegerToMaybesqlEqualsTypes sqlEquals sqlIsNullisSQLNullableTypeisSQLNullableSpecificTypeisSQLNullUnknownTypeeitherAtomTypeeitherTypeConstructorMappingeitherAtomFunctionsbasicTypeConstructorMapping AtomableGtoAtomG fromAtomG toAtomTypeGtoAtomsGtoAddTypeExprGgetConstructorsGgetConstructorArgsGAtomabletoAtomfromAtom toAtomType toAddTypeExprtypeToTypeConstructor$fAtomableGk:+:$fAtomableGk:*:$fAtomableGkU1$fAtomableGkM1$fAtomableGkM10$fAtomableGkM11$fAtomableGkK1$fAtomableNonEmpty $fAtomable[]$fAtomableEither$fAtomableMaybe$fAtomableUUID$fAtomableBool$fAtomableByteString$fAtomableUTCTime $fAtomableDay$fAtomableText$fAtomableDouble $fAtomableInt$fAtomableInteger TupleableGtoTupleG toAttributesG fromTupleG isRecordTypeGTupleableOptions fieldModifier TupleabletoTuple fromTuple toAttributes toInsertExpr toDefineExprtupleAssocsEqualityPredicatepartitionByAttributes toUpdateExpr toDeleteExprdefaultTupleableOptionsgenericToTuplegenericFromTuplegenericToAttributes$fTupleableGU1$fTupleableGM1$fTupleableG:*:$fTupleableGM10$fTupleableGM11>>><<<AsIs TrainCase SpinalCase SnakeCase PascalCase CamelCase TitleCase LowerCase UpperCase DropSuffix AddSuffix DropPrefix AddPrefix ModifyText modifyTextField ModifyOptions modifyOptionsCodecunCodec$fModifyOptions()$fTupleableCodec$fModifyText()$fModifyOptionsField$fModifyTextAddPrefix$fModifyTextDropPrefix$fModifyTextAddSuffix$fModifyTextDropSuffix$fModifyTextUpperCase$fModifyTextLowerCase$fModifyTextTitleCase$fModifyTextCamelCase$fModifyTextPascalCase$fModifyTextSnakeCase$fModifyTextSpinalCase$fModifyTextTrainCase$fModifyText<<<$fModifyOptions<<<$fModifyText>>>$fModifyOptions>>>Boolean&&&||| HaskAtomTypeIntIntegerDoubleTextBoolAttr toAtomType''relation relation'tuple!!><allButallFromas#:@@f#::#:=@~truefalsetruePfalseP?=not' toAtomExpr$fConvertibleaAtomExprBase$fConvertibleRestrictionPredicateExprBaseRestrictionPredicateExprBase5$fConvertibleAtomExprBaseRestrictionPredicateExprBase;$fConvertibleRelationalExprBaseRestrictionPredicateExprBase*$fConvertibleaRestrictionPredicateExprBase#$fConvertibleTextRelationalExprBase+$fConvertibleRelationalExprBaseAtomExprBase$fConvertibleTextAtomExprBase%$fConvertibleAtomExprBaseAtomExprBase$fIsLabelxAtomExprBase $fIsLabelxFUN$fIsLabelxFUN0$fIsLabelxFUN1$fIsLabelxRelationalExprBase$fIsLabelxText$fIsListTupleExprBase$fIsListTupleExprsBase$fIsListAttributeNamesBase$fIsLabelxFUN2 $fBooleanabprimitiveAtomFunctionsintegerAtomFuncLessThan boolAtomNot relationSum relationCount relationMax relationMin relationMeancastInt castIntegerscientificAtomFunctions PlotErrorInvalidAttributeCountErrorInvalidAttributeTypeErrorintFromAtomIndexgraph1DRelationpoints1DRelationgraph2DRelationpoints2DRelationgraph3DRelationpoints3DRelation plotRelation$fShowPlotErrorbasicAtomFunctionsprecompiledAtomFunctionsObjectFileInfo _unFileInfogetDirectoryNamestempTransactionDirtransactionDirtransactionInfoPathnotificationsPath relvarsPath incDepsDir atomFuncsPath dbcFuncsPath typeConsPathsubschemasPathregisteredQueriesPathaggregateFunctionsPathobjectFilesPathreadTransactionwriteTransaction writeRelVars readRelVars writeFuncs readFuncsloadFunc readAtomFunc writeIncDep writeIncDeps readIncDep readIncDepsreadSubschemaswriteSubschemaswriteTypeConstructorMappingreadTypeConstructorMappingreadRegisteredQuerieswriteRegisteredQueriesreadNotificationswriteNotifications$fShowObjectFileInfo$fSerialiseObjectFileInfostripGraphRefRelationalExpr$databaseContextAsDatabaseContextExprbasicDatabaseContextsomeDatabaseContextExprssqlDatabaseContext dateExamples suppliersRelsupplierProductsRel productsRel WithTCMap arbitrary' maybeToRightarbitraryRelationTuplearbitraryWithRangearbitraryRelationcreateArbitraryInterval wIDEEASTASIAN zEROWIDTH basicZero ctrlCharswcwidthTableCellboxVboxHboxTLboxTRboxBLboxBRboxLBboxRBboxTBboxBBboxCaddRow cellLocations breakLines cellSizesrelationAsTable showParensshowAtom renderTable renderHeader renderHBarleftPaddedString renderRow renderBody repeatString showRelationstringDisplayLength DataFrameExpr convertExpr orderExprsoffsetlimitDataFrameTuple DataFrameorderstuplesOrderAscendingOrderDescendingOrderAttributeOrderAttributeOrderExpr ascending descending arbitrarysortDataFrameBy sortTuplesBycompareTupleByAttributeOrderscompareTupleByOneAttributeNametake'drop' toDataFrame fromDataFrame showDataFramedataFrameAsTableusesDataFrameFeaturesnakedDataFrameExprdataFrameAsHTML tuplesAsHTML $fEqDataFrame$fShowDataFrameExpr$fGenericDataFrameExpr$fEqDataFrameExpr$fShowDataFrame$fGenericDataFrame$fEqDataFrameTuple$fShowDataFrameTuple$fGenericDataFrameTuple$fHashableDataFrameTuple$fShowAttributeOrderExpr$fGenericAttributeOrderExpr$fEqAttributeOrderExpr$fShowAttributeOrder$fGenericAttributeOrder$fEqAttributeOrder $fEqOrder $fShowOrder$fGenericOrder$fSerialiseDataFrameExpr$fSerialiseDataFrameTuple$fSerialiseDataFrame$fSerialiseOrder$fSerialiseAttributeOrder$fSerialiseAttributeOrderExprlookupsubstituteWithNameMacros,substituteWithNameMacrosRestrictionPredicate&substituteWitNameMacrosExtendTupleExpr substituteWithNameMacrosAtomExpr&substituteWithNameMacrosAttributeNames ResolveGraphRefTransactionMarkerresolveDatabaseContextM getContextDatabaseContextIOEvalMonadDatabaseContextIOEvalEnv dbcio_transId dbcio_graphdbcio_mScriptSessiondbcio_mModulesDirectoryGraphRefRelationalExprMGraphRefRelationalExprEnv gre_context gre_graph gre_extraDatabaseContextEvalMonadDatabaseContextEvalEnv dce_transId dce_graphDatabaseContextEvalState dbc_context dbc_accum dbc_dirty ResultAccumresultAccumFuncresultAccumResultResultAccumFuncResultAccumNameRelationalExprMRelationalExprEnv re_contextre_graphre_extraDatabaseContextExprDetailsCountUpdatedTuplesdatabaseContextExprDetailsFuncmkDatabaseContextEvalStateenvTuple envAttributesrunRelationalExprMreGraph reContextmkRelationalExprEnvaskEnv(mergeTuplesIntoGraphRefRelationalExprEnv,mergeAttributesIntoGraphRefRelationalExprEnvmkDatabaseContextEvalEnvrunDatabaseContextEvalMonad dbcTransIddbcGraphdbcRelationalExprEnvgetStateContextputStateContext gfTransForIdgfDatabaseContextForMarkerrunGraphRefRelationalExprMfreshGraphRefRelationalExprEnvgfGraph envContext setEnvContext setRelVar deleteRelVarevalGraphRefDatabaseContextExprrunDatabaseContextIOEvalMonadrequireScriptSessionputDBCIOContextgetDBCIOContextgetDBCIORelationalExprEnv!evalGraphRefDatabaseContextIOExprcheckConstraintstypeForRelationalExprliftEpredicateRestrictionFiltertupleExprCheckNewAttrName&extendGraphRefTupleExpressionProcessorevalGraphRefAtomExprtypeForGraphRefAtomExprverifyGraphRefAtomExprTypesevalGraphRefAttrExprevalGraphRefTupleExprsevalGraphRefTupleExprevalGraphRefRelationalExprdbContextForTransIdtransactionForIdtypeForGraphRefRelationalExprevalGraphRefAttributeNamesevalGraphRefAttributeExprmkEmptyRelVarsdbErrrelationVariablesAsRelationevalRelationalExpr relVarByNameapplyUnionCollapseapplyRestrictionCollapsefirstAtomForAttributeNameaddTargetTypeHintsvalidateNotification$fShowRelationalExprEnv$fDatabaseContextMRWST$fDatabaseContextMReaderT.$fResolveGraphRefTransactionMarkerAtomExprBase2$fResolveGraphRefTransactionMarkerWithNameExprBase5$fResolveGraphRefTransactionMarkerExtendTupleExprBase>$fResolveGraphRefTransactionMarkerRestrictionPredicateExprBase4$fResolveGraphRefTransactionMarkerAttributeNamesBase/$fResolveGraphRefTransactionMarkerTupleExprBase0$fResolveGraphRefTransactionMarkerTupleExprsBase4$fResolveGraphRefTransactionMarkerRelationalExprBasePosOneTwo LockFileHashexpectedVersiontransactionLogFileNametransactionLogPath headsPath lockFilePathcheckForOtherVersionssetupDatabaseDirbootstrapDatabaseDirtransactionGraphPersisttransactionsPersisttransactionGraphHeadsPersisttransactionGraphHeadsLoadtwowordstransactionGraphLoadreadTransactionIfNecessarywriteGraphTransactionIdFile readGraphTransactionIdFileDigestreadGraphTransactionIdFilereadUTF8FileOrErrorMergePreference PreferFirst PreferSecond PreferNeitherunionMergeMapsunionMergeRelationunionMergeRelVarsunionMergeAtomFunctions unionMergeTypeConstructorMapping"unionMergeDatabaseContextFunctionsunionMergeRegisteredQueries GroupByInfo aggregates nonAggregateshavingRestriction GroupByItemAggGroupByItemNonAggGroupByItem ColumnRemapColumnAliasRenameMapColumnAliasMapColumnAliasRemapperAttributeAliasSelectItemsConvertTasktaskProjections taskRenames taskExtenders taskGroupsConvertMTypeForRelExprF TableContext runConvertMrunLocalConvertM evalConvertM emptyTaskinsertIntoColumnAliasRemap'insertColumnAliasprettyTableContextprettyColumnAliasRemappertableAliasesAsWithNameAssocs throwSQLE withSubSelectgenerateColumnAlias insertTablenoteColumnMention lookupTable findColumn findColumn'findNotedColumn'attributeNameForAttributeAlias findOneColumnfindOneColumn'attributeNameForColumnName wrapTypeF baseDFExpr falseDFExpr convertQuery convertSelectappendWithsToTypeFconvertSubSelectconvertSelectItemconvertProjectionconvertUnqualifiedColumnNameconvertColumnNameconvertColumnProjectionNameconvertTableExprfuncconvertWhereClauseconvertScalarExprconvertProjectionScalarExprconvertOrderByClauseconvertWithClauseconvertFromClauseconvertTableRef joinTableReflookupOperator lookupFunccommonAttributeNamesrenameIdentifiercolumnNamesInScalarExprcolumnNamesInRestrictionExprneedsToRenameAllAttributespushDownAttributeRename!mkTableContextFromDatabaseContext convertUpdateconvertTableNameconvertDBUpdatesconvertDBUpdate convertInsert convertDeleteconvertCreateTableconvertDropTableconvertColumnNamesAndTypesconvertColumnTypeconvertPerColumnConstraints'databaseContextExprForUniqueKeyWithNullconvertGroupByemptyGroupByInfoaggregateFunctionsMapisAggregateFunctioncontainsAggregatecontainsProjScalarExprreplaceProjScalarExprprocessSQLAggregateFunctions$fShowGroupByInfo$fEqGroupByInfo$fShowGroupByItem$fEqGroupByItem$fSemigroupTableContext$fMonoidTableContext$fShowTableContext$fEqTableContext$fShowSelectItemsConvertTask$fEqSelectItemsConvertTaskReferencedTransactionIdsreferencedTransactionIdsTransactionIds&referencedTransactionIdsForTransaction$fReferencedTransactionIdsMap)$fReferencedTransactionIdsDatabaseContext&$fReferencedTransactionIdsAtomExprBase*$fReferencedTransactionIdsWithNameExprBase-$fReferencedTransactionIdsExtendTupleExprBase6$fReferencedTransactionIdsRestrictionPredicateExprBase,$fReferencedTransactionIdsAttributeNamesBase3$fReferencedTransactionIdsGraphRefTransactionMarker($fReferencedTransactionIdsTupleExprsBase'$fReferencedTransactionIdsTupleExprBase+$fReferencedTransactionIdsAttributeExprBase,$fReferencedTransactionIdsRelationalExprBaseMorph morphToSchema SchemaExpr AddSubschemaRemoveSubschema isomorphsvalidateSchemainvertisomorphInRelVarNamesisomorphsInRelVarNamesisomorphOutRelVarNamesisomorphsOutRelVarNamesvalidateRelationalExprInSchemaprocessRelationalExprInSchema#validateDatabaseContextExprInSchema"processDatabaseContextExprInSchema&processDatabaseContextExprSchemaUpdate'processDatabaseContextExprSchemasUpdate relExprMorphrelExprMogrifydatabaseContextExprMorph"applyRelationalExprSchemaIsomorphsinclusionDependencyInSchemainclusionDependenciesInSchemarelationVariablesInSchema#relationVariablesAsRelationInSchemacreateIncDepsForIsomorphevalSchemaExprnotificationsAsRelationInSchemanotificationsAsData $fMorphMap$fMorphInclusionDependency$fMorphRelationalExprBase$fGenericSchemaExpr$fShowSchemaExpr$fSerialiseSchemaExpr#registeredQueriesAsRelationInSchemaSHash HashBytes hashBytes SecureHash _unSecureHash hashBytesLhashTransaction mkDDLHash$fHashBytesUTCTime$fHashBytesMerkleHash$fHashBytesUUID $fHashBytes()$$fHashBytesGraphRefTransactionMarker$fHashBytesText$fHashBytesMap $fHashBytesDataConstructorDefArg$fHashBytesFunctionBody$fHashBytesTypeConstructorDef $fHashBytes[]$fHashBytesDataConstructorDef$fHashBytesNotification$fHashBytesInclusionDependency$fHashBytesHashSet$fHashBytesFunction$fHashBytesFunction0$fHashBytesHashSet0$fHashBytes[]0$fHashBytesMap0$fHashBytesMap1$fHashBytesMap2$fHashBytesDatabaseContext'$fHashBytesRestrictionPredicateExprBase$fHashBytesSchemaIsomorph$fHashBytesSchema$fHashBytesTypeConstructorBase$fHashBytesAttributeExprBase$fHashBytesRelationTuple$fHashBytes(,)$fHashBytesAttribute$fHashBytesTupleExprsBase$fHashBytesMaybe$fHashBytesRelationTupleSet$fHashBytesAttributes$fHashBytesAtomType$fHashBytesAtomExprBase$fHashBytesTupleExprBase$fHashBytesWithNameExprBase$fHashBytesSet$fHashBytesExtendTupleExprBase$fHashBytesAttributeNamesBase$fHashBytesRelationalExprBase$fHashBytesRelation$fHashBytesAtom$fSerialiseSecureHash$fShowSecureHash$fEqSecureHashMerkleValidationErrorROTransactionGraphOperator ShowGraphValidateMerkleHashesTransactionGraphOperator JumpToHeadJumpToTransactionWalkBackToTimeBranch DeleteBranchMergeTransactionsCommitRollbackTransactionIdHeadBacktrack TransactionIdHeadParentBacktrack TransactionIdHeadBranchBacktrackTransactionStampHeadBacktrackTransactionIdLookupTransactionIdHeadNameLookupisCommitbootstrapTransactionGraphfreshTransactionGraphemptyTransactionGraphtransactionForHeadheadListheadNameForTransactiontransactionsForIdsisRootTransactionrootTransactionsparentTransactionschildTransactions addBranchaddDisconnectedTransactionaddTransactionToGraphnewTransUncommittedReplace validateGraphwalkParentTransactionswalkChildTransactions evalGraphOpgraphAsRelationtransactionParentsRelationcreateMergeTransactionvalidateHeadNamesubGraphOfFirstCommonAncestorpathToTransactionmergeTransactionsshowTransactionStructureXshowGraphStructureXfilterSubGraphcreateUnionMergeTransactionlookupTransaction traverseGraphbacktrackGraphautoMergeToHead addMerkleHashcalculateMerkleHashvalidateMerkleHashvalidateMerkleHashesvalidateConnectivity$fShowMerkleValidationError$fEqMerkleValidationError$fGenericMerkleValidationError $fShowROTransactionGraphOperator$fEqTransactionGraphOperator$fShowTransactionGraphOperator!$fGenericTransactionGraphOperator#$fSerialiseTransactionGraphOperator$fShowTransactionIdLookup$fEqTransactionIdLookup$fGenericTransactionIdLookup$fSerialiseTransactionIdLookup $fShowTransactionIdHeadBacktrack$fEqTransactionIdHeadBacktrack#$fGenericTransactionIdHeadBacktrack%$fSerialiseTransactionIdHeadBacktrackshowTransactionStructureshowGraphStructureTransGraphEvalMonadTransGraphEvalEnv tge_graphTransGraphWithNameExprTransGraphAttributeExprTransGraphAtomExpr"TransGraphRestrictionPredicateExprTransGraphTupleExprsTransGraphTupleExprTransGraphExtendTupleExprTransGraphAttributeNamesTransGraphRelationalExprprocessaskGraph findTransId findTransprocessTransGraphRelationalExprprocessTransGraphTupleExprsprocessTransGraphTupleExprprocessTransGraphAtomExpr&evalTransGraphRestrictionPredicateExpr processTransGraphExtendTupleExprprocessTransGraphAttributeExprprocessTransGraphAttributeNamesprocessTransGraphWithNameExprAskGraphContext askContext GraphRefSOptDatabaseContextExprM"GraphRefSOptDatabaseContextExprEnv odce_graph odce_context odce_transIdGraphRefSOptRelationalExprMGraphRefSOptRelationalExprEnv ore_graph ore_mcontextoptimizeAndEvalRelationalExproptimizeRelationalExpr askTransIdaskMaybeContextoptimizeDatabaseContextExpr"optimizeAndEvalDatabaseContextExpr'optimizeAndEvalTransGraphRelationalExpr$optimizeAndEvalDatabaseContextIOExprrunGraphRefSOptRelationalExprM#runGraphRefSOptDatabaseContextExprMoptimizeGraphRefRelationalExpr'liftGraphRefRelExpr"fullOptimizeGraphRefRelationalExproptimizeGraphRefRelationalExpr#optimizeGraphRefDatabaseContextExpr applyStaticPredicateOptimization isTrueExpr isFalseExprisEmptyRelationExprreplaceStaticAtomExprsfindStaticRestrictionPredicatesisStaticAtomExprapplyStaticJoinEliminationapplyStaticRestrictionCollapsesequentialRestrictionsapplyStaticRestrictionPushdownapplyRedundantRenameCleanupoptimizeDatabaseContextIOExpr$fAskGraphContextReaderT$fAskGraphContextReaderT0notificationChangesConvertSQLUpdatesConvertSQLQueryRetrieveRegisteredQueriesRetrieveDDLAsRelation GetDDLHashExecuteValidateMerkleHashesRetrieveTypeConstructorMappingExecuteAutoMergeToHeadRetrieveSessionIsDirty TestTimeoutRetrieveCurrentSchemaName&RetrieveDatabaseContextFunctionSummaryRetrieveAtomFunctionSummaryRetrieveRelationVariableSummaryRetrieveNotificationsAsRelationRetrieveAtomTypesAsRelation CloseSessionCreateSessionAtHeadCreateSessionAtCommitRetrieveHeadTransactionIdRetrieveTransactionGraph"RetrievePlanForDatabaseContextExprRetrieveInclusionDependenciesExecuteSetCurrentSchemaExecuteSchemaExprExecuteTypeForRelationalExprExecuteHeadNameExecuteTransGraphRelationalExprExecuteGraphExprExecuteDatabaseContextIOExprExecuteDatabaseContextExprExecuteDataFrameExprExecuteRelationalExprLogoutLogin$fGenericConvertSQLUpdates$fSerialiseConvertSQLUpdates$fGenericConvertSQLQuery$fSerialiseConvertSQLQuery"$fGenericRetrieveRegisteredQueries$$fSerialiseRetrieveRegisteredQueries$fGenericRetrieveDDLAsRelation $fSerialiseRetrieveDDLAsRelation$fGenericGetDDLHash$fSerialiseGetDDLHash$$fGenericExecuteValidateMerkleHashes&$fSerialiseExecuteValidateMerkleHashes'$fGenericRetrieveTypeConstructorMapping)$fSerialiseRetrieveTypeConstructorMapping$fGenericExecuteAutoMergeToHead!$fSerialiseExecuteAutoMergeToHead$fGenericRetrieveSessionIsDirty!$fSerialiseRetrieveSessionIsDirty$fGenericTestTimeout$fSerialiseTestTimeout"$fGenericRetrieveCurrentSchemaName$$fSerialiseRetrieveCurrentSchemaName/$fGenericRetrieveDatabaseContextFunctionSummary1$fSerialiseRetrieveDatabaseContextFunctionSummary$$fGenericRetrieveAtomFunctionSummary&$fSerialiseRetrieveAtomFunctionSummary($fGenericRetrieveRelationVariableSummary*$fSerialiseRetrieveRelationVariableSummary($fGenericRetrieveNotificationsAsRelation*$fSerialiseRetrieveNotificationsAsRelation$$fGenericRetrieveAtomTypesAsRelation&$fSerialiseRetrieveAtomTypesAsRelation$fGenericCloseSession$fSerialiseCloseSession$fGenericCreateSessionAtHead$fSerialiseCreateSessionAtHead$fGenericCreateSessionAtCommit $fSerialiseCreateSessionAtCommit"$fGenericRetrieveHeadTransactionId$$fSerialiseRetrieveHeadTransactionId!$fGenericRetrieveTransactionGraph#$fSerialiseRetrieveTransactionGraph+$fGenericRetrievePlanForDatabaseContextExpr-$fSerialiseRetrievePlanForDatabaseContextExpr&$fGenericRetrieveInclusionDependencies($fSerialiseRetrieveInclusionDependencies $fGenericExecuteSetCurrentSchema"$fSerialiseExecuteSetCurrentSchema$fGenericExecuteSchemaExpr$fSerialiseExecuteSchemaExpr%$fGenericExecuteTypeForRelationalExpr'$fSerialiseExecuteTypeForRelationalExpr$fGenericExecuteHeadName$fSerialiseExecuteHeadName($fGenericExecuteTransGraphRelationalExpr*$fSerialiseExecuteTransGraphRelationalExpr$fGenericExecuteGraphExpr$fSerialiseExecuteGraphExpr%$fGenericExecuteDatabaseContextIOExpr'$fSerialiseExecuteDatabaseContextIOExpr#$fGenericExecuteDatabaseContextExpr%$fSerialiseExecuteDatabaseContextExpr$fGenericExecuteDataFrameExpr$fSerialiseExecuteDataFrameExpr$fGenericExecuteRelationalExpr $fSerialiseExecuteRelationalExpr$fGenericLogout$fSerialiseLogout$fGenericLogin$fSerialiseLoginexecuteDatabaseContextExprexecuteRelationalExprddlHashtypesForRelationVariablesddlTypeConnectionErrorSetupDatabaseDirectoryErrorIOExceptionErrorNoSuchDatabaseByNameErrorDatabaseValidationError LoginError ConnectionInProcessConnectionRemoteConnectionEvaluatedNotification notificationreportOldRelationreportNewRelationConnectionInfoInProcessConnectionInfoRemoteConnectionInfoRequestTimeoutExceptionRemoteProcessDiedExceptionNotificationCallbackRemoteServerAddressRemoteServerHostAddress#RemoteServerUnixDomainSocketAddressPortHostnameemptyNotificationCallbackdefaultServerPortdefaultDatabaseNamedefaultHeadNamedefaultRemoteServerAddressdefaultRemoteConnectionInfodefaultServerHostnameremoteDBLookupNameresolveRemoteServerAddressconnectProjectM36 addClientNodecreateSessionAtCommitcreateSessionAtHead closeSessionclose closeRemote_currentSchemaNamesetCurrentSchemaNameexecuteDatabaseContextIOExprexecuteGraphExprexecuteTransGraphRelationalExprexecuteSchemaExprcommitrollbackplanForDatabaseContextExprtransactionGraphAsRelation ddlAsRelationnotificationsAsRelationheadTransactionIdheadNameatomTypesAsRelationdisconnectedTransactionIsDirtycallTestTimeout_transactionGraph_disconnectedTransaction_withTransactionexecuteDataFrameExpr getDDLHashconvertSQLQueryconvertSQLDBUpdatesregisteredQueriesAsRelation%$fExceptionRemoteProcessDiedException"$fExceptionRequestTimeoutException$fHashableClientInfo$fEqClientInfo$fShowConnectionError$fEqConnectionError$fGenericConnectionError$fEqNotificationMessage$fShowNotificationMessage$fGenericNotificationMessage$fSerialiseNotificationMessage$fEqEvaluatedNotification$fShowEvaluatedNotification$fGenericEvaluatedNotification $fSerialiseEvaluatedNotification$fShowRequestTimeoutException$fEqRequestTimeoutException $fShowRemoteProcessDiedException$fEqRemoteProcessDiedException$fShowRemoteServerAddress timeoutOrDie timeoutRelErrhandleExecuteRelationalExprhandleExecuteDataFrameExpr handleExecuteDatabaseContextExpr"handleExecuteDatabaseContextIOExprhandleExecuteHeadName handleLoginhandleExecuteGraphExpr%handleExecuteTransGraphRelationalExpr"handleExecuteTypeForRelationalExpr#handleRetrieveInclusionDependencies(handleRetrievePlanForDatabaseContextExprhandleRetrieveTransactionGraphhandleRetrieveHeadTransactionIdhandleCreateSessionAtCommithandleCreateSessionAtHeadhandleCloseSession!handleRetrieveAtomTypesAsRelation%handleRetrieveRelationVariableSummary!handleRetrieveAtomFunctionSummary,handleRetrieveDatabaseContextFunctionSummaryhandleRetrieveCurrentSchemaNamehandleExecuteSchemaExpr handleLogouthandleTestTimeouthandleRetrieveSessionIsDirtyhandleExecuteAutoMergeToHead$handleRetrieveTypeConstructorMappinghandleValidateMerkleHasheshandleGetDDLHashhandleRetrieveDDLAsRelationhandleRetrieveRegisteredQuerieshandleConvertSQLQueryhandleConvertSQLUpdates%handleRetrieveNotificationsAsRelationWebsocketServerConfigwsServerConfigtlsCertificatePath tlsKeyPath ServerConfigpersistenceStrategycheckFS databaseName bindAddress ghcPkgPathsperRequestTimeouttestModedefaultServerConfig$fShowWebsocketServerConfig$fShowServerConfigparseArgsWithDefaultsparsePersistenceStrategy parseTestMode parseCheckFSparseServerAddressparseUnixDomainSocketPathparseDatabaseName parseHostname parsePortparseGhcPkgPath parseTimeout parseConfigparseConfigWithDefaultsparseWSConfigWithDefaultsparseWSArgsWithDefaultsparseTlsCertificatePathparseTlsKeyPath helpOption ServerState stateDBMapstateClientMap SocketStringTestModerequestHandlersgetConntestModeHandlersloggingNotificationCallback checkFSTypecheckFSErrorMsgaddClientLoginconnectionForClientinitialServerState launchServerDbError ConnErrorRelErrorTransactionRolledBackDbDbConnsimpleConnectProjectM36AtsimpleConnectProjectM36withTransactionUsingexecutequery executeOrErr queryOrErrcancelTransactionorCancelTransaction$fExceptionTransactionCancelled$fShowTransactionCancelled $fEqDbError $fShowDbError $fFunctorDb$fApplicativeDb $fMonadDb $fMonadIODb text-1.2.5.0Data.Text.InternalNotificationMessage"processTransactionGraphPersistence Data.EitherEither