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

• 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 withOpenSession). 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.

• sessionTracer :: !(Tracer m LSMTreeTrace)
   

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.

• sessionHasFS :: !(HasFS m h)
   
• sessionHasBlockIO :: !(HasBlockIO m h)
   
• sessionLockFile :: !(LockFileHandle m)
   
• sessionUniqCounter :: !(UniqCounter m)

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

• 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.

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 withOpenTable). 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.