Rename TableHandle to Table

Author: jorisdral

bench/macro/lsm-tree-bench-wp8.hs

@@ -614,7 +614,7 @@ type LookupResults = V.Vector (K, LSM.LookupResult V ())
 sequentialIteration :: (Int -> LookupResults -> IO ())
                     -> Int
                     -> Int
-                    -> LSM.TableHandle IO K V B
+                    -> LSM.Table IO K V B
                     -> Int
                     -> MCG.MCG
                     -> IO MCG.MCG
@@ -633,7 +633,7 @@ sequentialIteration output !initialSize !batchSize !tbl !b !g = do
 
 sequentialIterations :: (Int -> LookupResults -> IO ())
                      -> Int -> Int -> Int -> Word64
-                     -> LSM.TableHandle IO K V B
+                     -> LSM.Table IO K V B
                      -> IO ()
 sequentialIterations output !initialSize !batchSize !batchCount !seed !tbl =
     void $ forFoldM_ g0 [ 0 .. batchCount - 1 ] $ \b g ->
@@ -645,7 +645,7 @@ sequentialIterations output !initialSize !batchSize !batchCount !seed !tbl =
 sequentialIterationLO :: (Int -> LookupResults -> IO ())
                       -> Int
                       -> Int
-                      -> LSM.TableHandle IO K V B
+                      -> LSM.Table IO K V B
                       -> Int
                       -> MCG.MCG
                       -> IO MCG.MCG
@@ -661,7 +661,7 @@ sequentialIterationLO output !initialSize !batchSize !tbl !b !g = do
 
 sequentialIterationsLO :: (Int -> LookupResults -> IO ())
                        -> Int -> Int -> Int -> Word64
-                       -> LSM.TableHandle IO K V B
+                       -> LSM.Table IO K V B
                        -> IO ()
 sequentialIterationsLO output !initialSize !batchSize !batchCount !seed !tbl =
     void $ forFoldM_ g0 [ 0 .. batchCount - 1 ] $ \b g ->
@@ -721,13 +721,13 @@ And the initial setup looks like this:
 pipelinedIteration :: (Int -> LookupResults -> IO ())
                    -> Int
                    -> Int
-                   -> MVar (LSM.TableHandle IO K V B, Map K (LSM.Update V B))
-                   -> MVar (LSM.TableHandle IO K V B, Map K (LSM.Update V B))
+                   -> MVar (LSM.Table IO K V B, Map K (LSM.Update V B))
+                   -> MVar (LSM.Table IO K V B, Map K (LSM.Update V B))
                    -> MVar MCG.MCG
                    -> MVar MCG.MCG
-                   -> LSM.TableHandle IO K V B
+                   -> LSM.Table IO K V B
                    -> Int
-                   -> IO (LSM.TableHandle IO K V B)
+                   -> IO (LSM.Table IO K V B)
 pipelinedIteration output !initialSize !batchSize
                    !syncTblIn !syncTblOut
                    !syncRngIn !syncRngOut
@@ -738,7 +738,7 @@ pipelinedIteration output !initialSize !batchSize
     -- 1: perform the lookups
     lrs <- LSM.lookups ls tbl_n
 
-    -- 2. sync: receive updates and new table handle
+    -- 2. sync: receive updates and new table
     putMVar syncRngOut g'
     (tbl_n1, delta) <- takeMVar syncTblIn
 
@@ -751,7 +751,7 @@ pipelinedIteration output !initialSize !batchSize
     tbl_n2 <- LSM.duplicate tbl_n1
     LSM.updates is tbl_n2
 
-    -- 4. sync: send the updates and new table handle
+    -- 4. sync: send the updates and new table
     let delta' :: Map K (LSM.Update V B)
         !delta' = Map.fromList (V.toList is)
     putMVar syncTblOut (tbl_n2, delta')
@@ -769,7 +769,7 @@ pipelinedIteration output !initialSize !batchSize
 
 pipelinedIterations :: (Int -> LookupResults -> IO ())
                     -> Int -> Int -> Int -> Word64
-                    -> LSM.TableHandle IO K V B
+                    -> LSM.Table IO K V B
                     -> IO ()
 pipelinedIterations output !initialSize !batchSize !batchCount !seed tbl_0 = do
     n <- getNumCapabilities

bench/micro/Bench/Database/LSMTree/Monoidal.hs

@@ -240,16 +240,16 @@ mkNormalTable ::
   -> FS.HasBlockIO IO FS.HandleIO
   -> Normal.TableConfig
   -> IO ( Normal.Session IO
-        , Normal.TableHandle IO K V B
+        , Normal.Table IO K V B
         )
 mkNormalTable hfs hbio conf = do
     sesh <- Normal.openSession nullTracer hfs hbio (FS.mkFsPath [])
-    th <- Normal.new sesh conf
-    pure (sesh, th)
+    t <- Normal.new sesh conf
+    pure (sesh, t)
 
 cleanupNormalTable ::
      ( Normal.Session IO
-     , Normal.TableHandle IO K V B
+     , Normal.Table IO K V B
      )
   -> IO ()
 cleanupNormalTable (s, t) = do
@@ -261,16 +261,16 @@ mkMonoidalTable ::
   -> FS.HasBlockIO IO FS.HandleIO
   -> Monoidal.TableConfig
   -> IO ( Monoidal.Session IO
-        , Monoidal.TableHandle IO K V
+        , Monoidal.Table IO K V
         )
 mkMonoidalTable hfs hbio conf = do
     sesh <- Monoidal.openSession nullTracer hfs hbio (FS.mkFsPath [])
-    th <- Monoidal.new sesh conf
-    pure (sesh, th)
+    t <- Monoidal.new sesh conf
+    pure (sesh, t)
 
 cleanupMonoidalTable ::
      ( Monoidal.Session IO
-     , Monoidal.TableHandle IO K V
+     , Monoidal.Table IO K V
      )
   -> IO ()
 cleanupMonoidalTable (s, t) = do

bench/micro/Bench/Database/LSMTree/Normal.hs

@@ -75,15 +75,15 @@ benchLargeValueVsSmallValueBlob :: Benchmark
 benchLargeValueVsSmallValueBlob =
     env mkEntries $ \es -> bgroup "large-value-vs-small-value-blob" [
         env (mkGrouped (mkV1 es)) $ \ ~(ess, kss) -> bgroup "V1" [
-            withEnv ess $ \ ~(_, _, _, _, t :: Normal.TableHandle IO K V1 B1) -> do
+            withEnv ess $ \ ~(_, _, _, _, t :: Normal.Table IO K V1 B1) -> do
               bench "lookups-large-value" $ whnfIO $
                 V.mapM_ (flip Normal.lookups t) kss
           ]
       , env (mkGrouped (mkV2 es)) $ \ ~(ess, kss) -> bgroup "V2" [
-            withEnv ess $ \ ~(_, _, _, _, t :: Normal.TableHandle IO K V2 B2) -> do
+            withEnv ess $ \ ~(_, _, _, _, t :: Normal.Table IO K V2 B2) -> do
               bench "lookups-small-value" $ whnfIO $
                 V.mapM_ (flip Normal.lookups t) kss
-           , withEnv ess $ \ ~(_, _, _, s, t :: Normal.TableHandle IO K V2 B2) -> do
+           , withEnv ess $ \ ~(_, _, _, s, t :: Normal.Table IO K V2 B2) -> do
               bench "lookups-small-value-blob" $ whnfIO $ do
                 V.forM_ kss $ \ks -> do
                   lrs <- Normal.lookups ks t
@@ -147,7 +147,7 @@ benchCursorScanVsRangeLookupScan :: Benchmark
 benchCursorScanVsRangeLookupScan =
     env mkEntries $ \es ->
       env (mkGrouped es) $ \ ess ->
-        withEnv ess $ \ ~(_, _, _, _, t :: Normal.TableHandle IO K V2 B2) ->
+        withEnv ess $ \ ~(_, _, _, _, t :: Normal.Table IO K V2 B2) ->
           bgroup "cursor-scan-vs-range-lookup-scan" [
               bench "cursor-scan-full" $ whnfIO $ do
                 Normal.withCursor t $ \c -> do

doc/format-directory.md

@@ -58,7 +58,7 @@ snapshots). This is because the metadata is held in memory for open LSM handles.
 The `${n}.wbblobs` file format is the same as the `${n}.blobs` format used for
 runs: the concatenation of all the blobs written out so far. These files can be
 shared between open tables (created using `duplicate`), and so can contain
-blobs inserted via many table handles.
+blobs inserted via many tables.
 
 The `${n}.wbblobs` files are ephemeral. They are never included into snapshots
 and are not referenced from any `.checksums` file.

doc/format-run.md

@@ -172,8 +172,8 @@ properties. In particular initially we will support a compact index type.
 For more general purpose applications one can foresee the need for a more
 ordinary index type.
 
-The type of index in use is metadata that must be known for the whole LSM table
-handle. It does not vary per run.
+The type of index in use is metadata that must be known for the whole LSM table.
+It does not vary per run.
 
 Independently of the concrete index serialization format, the type and the
 version of the format are stored at the beginning as a 32-bit number called the

src-extras/Database/LSMTree/Extras/NoThunks.hs

@@ -84,26 +84,26 @@ prop_NoThunks x =
   Public API
 -------------------------------------------------------------------------------}
 
--- | Also checks 'NoThunks' for the 'Normal.TableHandle's that are known to be
+-- | Also checks 'NoThunks' for the 'Normal.Table's that are known to be
 -- open in the 'Common.Session'.
 instance (NoThunksIOLike m, Typeable m, Typeable (PrimState m))
       => NoThunks (Session' m ) where
   showTypeOf (_ :: Proxy (Session' m)) = "Session'"
   wNoThunks ctx (Session' s) = wNoThunks ctx s
 
 -- | Does not check 'NoThunks' for the 'Common.Session' that this
--- 'Normal.TableHandle' belongs to.
+-- 'Normal.Table' belongs to.
 instance (NoThunksIOLike m, Typeable m, Typeable (PrimState m))
       => NoThunks (NormalTable m k v blob) where
   showTypeOf (_ :: Proxy (NormalTable m k v blob)) = "NormalTable"
-  wNoThunks ctx (NormalTable th) = wNoThunks ctx th
+  wNoThunks ctx (NormalTable t) = wNoThunks ctx t
 
 {-------------------------------------------------------------------------------
   Internal
 -------------------------------------------------------------------------------}
 
 deriving stock instance Generic (Internal.Session m h)
--- | Also checks 'NoThunks' for the 'Internal.TableHandle's that are known to be
+-- | Also checks 'NoThunks' for the 'Internal.Table's that are known to be
 -- open in the 'Internal.Session'.
 deriving anyclass instance (NoThunksIOLike m, Typeable m, Typeable h, Typeable (PrimState m))
                         => NoThunks (Internal.Session m h)
@@ -116,20 +116,20 @@ deriving stock instance Generic (SessionEnv m h)
 deriving anyclass instance (NoThunksIOLike m, Typeable m, Typeable h, Typeable (PrimState m))
                         => NoThunks (SessionEnv m h)
 
-deriving stock instance Generic (Internal.TableHandle m h)
+deriving stock instance Generic (Internal.Table m h)
 -- | Does not check 'NoThunks' for the 'Internal.Session' that this
--- 'Internal.TableHandle' belongs to.
+-- 'Internal.Table' belongs to.
 deriving anyclass instance (NoThunksIOLike m, Typeable m, Typeable h, Typeable (PrimState m))
-                        => NoThunks (Internal.TableHandle m h)
+                        => NoThunks (Internal.Table m h)
 
-deriving stock instance Generic (TableHandleState m h)
+deriving stock instance Generic (TableState m h)
 deriving anyclass instance (NoThunksIOLike m, Typeable m, Typeable h, Typeable (PrimState m))
-                        => NoThunks (TableHandleState m h)
+                        => NoThunks (TableState m h)
 
-deriving stock instance Generic (TableHandleEnv m h)
-deriving via AllowThunksIn ["tableSession", "tableSessionEnv"] (TableHandleEnv m h)
+deriving stock instance Generic (TableEnv m h)
+deriving via AllowThunksIn ["tableSession", "tableSessionEnv"] (TableEnv m h)
     instance (NoThunksIOLike m, Typeable m, Typeable h, Typeable (PrimState m))
-          => NoThunks (TableHandleEnv m h)
+          => NoThunks (TableEnv m h)
 
 -- | Does not check 'NoThunks' for the 'Internal.Session' that this
 -- 'Internal.Cursor' belongs to.

src/Database/LSMTree/Common.hs

@@ -82,7 +82,7 @@ instance IOLike IO
   Sessions
 -------------------------------------------------------------------------------}
 
--- | A session provides context that is shared across multiple table handles.
+-- | A session provides context that is shared across multiple tables.
 --
 -- Sessions are needed to support sharing between multiple table instances.
 -- Sharing occurs when tables are duplicated using 'duplicate', or when tables
@@ -171,8 +171,8 @@ openSession tr hfs hbio dir = Internal.Session' <$> Internal.openSession tr hfs
 -- | Close the table session. 'closeSession' is idempotent. All subsequent
 -- operations on the session or the tables within it will throw an exception.
 --
--- This also closes any open table handles and cursors in the session. It would
--- typically be good practice however to close all table handles first rather
+-- This also closes any open tables and cursors in the session. It would
+-- typically be good practice however to close all tables first rather
 -- than relying on this for cleanup.
 --
 -- Closing a table session allows the session to be opened again elsewhere, for
@@ -242,12 +242,12 @@ listSnapshots (Internal.Session' sesh) = Internal.listSnapshots sesh
 --
 -- Though blob references are handle-like, they /do not/ keep files open. As
 -- such, when a blob reference is returned by a lookup, modifying the
--- corresponding table handle, cursor, or session /may/ cause the blob reference
+-- corresponding table, cursor, or session /may/ cause the blob reference
 -- to be invalidated (i.e.., the blob has gone missing because the blob file was
 -- removed). These operations include:
 --
 -- * Updates (e.g., inserts, deletes, mupserts)
--- * Closing table handles
+-- * Closing tables
 -- * Closing cursors
 -- * Closing sessions
 --
@@ -256,7 +256,7 @@ listSnapshots (Internal.Session' sesh) = Internal.listSnapshots sesh
 -- do /not/ invalidate blob references. These operations do not modify the
 -- logical contents or state of a table.
 --
--- [Blob reference validity] as long as the table handle or cursor that the blob
+-- [Blob reference validity] as long as the table or cursor that the blob
 -- reference originated from is not updated or closed, the blob reference will
 -- be valid.
 --