Fields

• !ByteCount

  Expected byte count.

• !ByteCount

  Actual byte count.

Fields

• !Int

  The index of the first table.

• !TypeRep

  The type of the filesystem handle of the first table.

• !Int

  The index of the second table.

• !TypeRep

  The type of the filesystem handle of the second table.

Fields

• !Int

  The index of the first table.

• !FsErrorPath

  The session directory of the first table.

• !Int

  The index of the second table.

• !FsErrorPath

  The session directory of the second table.

Fields

• !SnapshotName
   
• !SnapshotLabel

  Expected label

• !SnapshotLabel

  Actual label

Fields

• !FsErrorPath

  File.

• !FileFormat

  File format.

• !String

  Error message.

Fields

• !FsErrorPath

  File.

• !Word32

  Expected checksum.

• !Word32

  Actual checksum.

Fields

• SessionId

  Sessions are identified by the path to their root directory.

• SessionTrace
   

Fields

• TableId

  Tables are identified by a unique number.

• TableTrace
   

Fields

• CursorId

  Cursors are identified by a unique number.

• CursorTrace
   

Fields

• SessionId

  The parent session

• TableConfig
   

Fields

• Int

  The number of keys that are looked up.

Fields

• Int

  The number of keys that will be updated.

Fields

• Int

  The number of keys that have been updated.

Fields

• TableId

  The parent table

Fields

• (NonEmpty TableId)

  Unique identifiers for the tables that are used as inputs to the union.

Fields

• UnionCredits

  The number of input credits that have been supplied.

• UnionCredits

  Leftover credits.

Fields

• SessionId

  The parent session

Fields

• TableId

  The parent table

• (Maybe RawBytes)

  The optional serialised key that is used as the initial offset for the cursor.

Fields

• Int

  Requested number of entries to read at most.

Fields

• Int

  Requested number of entries to read at most.

• Int

  Actual number of entries read.

Fields

• sessionState :: !(RWVar m (SessionState m h))

  The primary purpose of this RWVar is to ensure consistent views of the open-/closedness of a session when multiple threads require access to the session's fields (see withKeepSessionOpen). We use more fine-grained synchronisation for various mutable parts of an open session.

  INVARIANT: once the session state is changed from SessionOpen to SessionClosed, it is never changed back to SessionOpen again.

• lsmTreeTracer :: !(Tracer m LSMTreeTrace)
   
• sessionTracer :: !(Tracer m SessionTrace)
   
• sessionUniqCounter :: !(UniqCounter m)

  A session-wide shared, atomic counter that is used to produce unique names, for example: run names, table IDs.

  This counter lives in Session instead of SessionEnv because it is an atomic counter, and so it does not need to be guarded by a lock.

Fields

• sessionRoot :: !SessionRoot

  The path to the directory in which this session is live. This is a path relative to root of the HasFS instance.

  INVARIANT: the session root is never changed during the lifetime of a session.

• sessionSalt :: !Salt

  Session-wide salt for bloomfilter hashes

  INVARIANT: all bloom filters in all tables in the session are created using the same salt, and all bloom filter are queried using that same salt.

• sessionHasFS :: !(HasFS m h)
   
• sessionHasBlockIO :: !(HasBlockIO m h)
   
• sessionLockFile :: !(LockFileHandle m)
   
• sessionOpenTables :: !(StrictMVar m (Map TableId (Table m h)))

  Open tables are tracked here so they can be closed once the session is closed. Tables also become untracked when they are closed manually.

  Tables are assigned unique identifiers using sessionUniqCounter to ensure that modifications to the set of known tables are independent. Each identifier is added only once in new, openTableFromSnapshot, duplicate, union, or unions, and is deleted only once in close or closeSession.

  • A new table may only insert its own identifier when it has acquired the sessionState read-lock. This is to prevent races with closeSession.
  • A table close may delete its own identifier from the set of open tables without restrictions, even concurrently with closeSession. This is safe because close is idempotent'.
• sessionOpenCursors :: !(StrictMVar m (Map CursorId (Cursor m h)))

  Similarly to tables, open cursors are tracked so they can be closed once the session is closed. See sessionOpenTables.

• sessionRefCtx :: !RefCtx

  The scope within which references exist. This context is created once a new session is created, and closed once the session is closed.

Fields

• tableConfig :: !TableConfig
   
• tableState :: !(RWVar m (TableState m h))

  The primary purpose of this RWVar is to ensure consistent views of the open-/closedness of a table when multiple threads require access to the table's fields (see withKeepTableOpen). We use more fine-grained synchronisation for various mutable parts of an open table.

• tableArenaManager :: !(ArenaManager (PrimState m))
   
• tableTracer :: !(Tracer m TableTrace)
   
• tableId :: !TableId

  Session-unique identifier for this table.

  INVARIANT: a table's identifier is never changed during the lifetime of the table.

• tableSession :: !(Session m h)

  The session that this table belongs to.

  INVARIANT: a table only ever belongs to one session, and can't be transferred to a different session.

Fields

• tableSessionEnv :: !(SessionEnv m h)

  Use this instead of tableSession for easy access. An open table may assume that its session is open.

• tableContent :: !(RWVar m (TableContent m h))

  All of the state being in a single StrictMVar is a relatively simple solution, but there could be more concurrency. For example, while inserts are in progress, lookups could still look at the old state without waiting for the MVar.

  TODO: switch to more fine-grained synchronisation approach

Fields

• cursorState :: !(StrictMVar m (CursorState m h))

  Mutual exclusion, only a single thread can read from a cursor at a given time.

• cursorTracer :: !(Tracer m CursorTrace)
   

Fields

• cursorSession :: !(Session m h)

  The session that this cursor belongs to.

  NOTE: Consider using the cursorSessionEnv field instead of acquiring the session lock.

• cursorSessionEnv :: !(SessionEnv m h)

  Use this instead of cursorSession for easy access. An open cursor may assume that its session is open. A session's global resources, and therefore resources that are inherited by the cursor, will only be released once the session is sure that no cursors are open anymore.

• cursorId :: !CursorId

  Session-unique identifier for this cursor.

• cursorReaders :: !(Maybe (Readers m h))

  Readers are immediately discarded once they are Drained, so if there is a Just, we can assume that it has further entries. Note that, while the readers do retain references on the blob files while they are active, once they are drained they do not. This could invalidate any BlobRefs previously handed out. To avoid this, we explicitly retain references on the runs and write buffer blofs and only release them when the cursor is closed (see cursorWBB and cursorRuns below).

• cursorWBB :: !(Ref (WriteBufferBlobs m h))

  The write buffer blobs, which like the runs, we have to keep open untile the cursor is closed.

• cursorRuns :: !(Vector (Ref (Run m h)))

  The runs from regular levels that are held open by the cursor. We must release these references when the cursor gets closed.

• cursorUnion :: !(Maybe (UnionCache m h))

  The runs from the union level that are held open by the cursor. We must release these references when the cursor gets closed.