NFC clean-ups. (#61)

Author: maleadt

docs/src/lib/errors.md

@@ -15,20 +15,6 @@ against `LMDB.MDB_*` constants directly.
 LMDBError
 ```
 
-## Status-code matchers
-
-```@docs
-is_notfound
-is_keyexist
-is_map_full
-```
-
-## Error helpers
-
-```@docs
-errormsg
-```
-
 ## Status constants
 
 The full set of LMDB status codes is exposed as `LMDB.MDB_*`. The

docs/src/man/environments.md

@@ -76,8 +76,7 @@ LMDB.MDB_RDONLY)` on an open env will return `EINVAL`.
 on-disk size. Pick a generous power of two (say, 1 GiB or 8 GiB) up
 front. The on-disk file grows incrementally as data is written.
 
-If a write txn would exceed `mapsize`, LMDB returns `MDB_MAP_FULL`
-(catchable via [`is_map_full(::LMDBError)`](@ref is_map_full)). To
+If a write txn would exceed `mapsize`, LMDB returns `MDB_MAP_FULL`. To
 recover, close the env, raise `mapsize`, and reopen. The database
 itself does not need rewriting.
 

docs/src/man/essentials.md

@@ -106,10 +106,6 @@ catch e
 end
 ```
 
-Common branches have helpers (`is_notfound`, `is_keyexist`,
-`is_map_full`); rarer codes can be matched against `LMDB.MDB_*`
-constants directly. See [Errors](@ref API-Errors) for the full list.
-
 For the usual "missing key" case, prefer the no-throw paths:
 [`tryget(txn, dbi, key, T)`](@ref tryget) returns `nothing` on miss,
 and `get(txn, dbi, key, T, default)` falls back to `default`.

src/common.jl

@@ -221,7 +221,7 @@ isflagset(value, flag) = (value & flag) == flag
 
 # Convert a raw `MDB_stat` (C field names) into the documented NamedTuple
 # returned from `stat(env)` and `stat(txn, dbi)`.
-@inline _stat_namedtuple(s::MDB_stat) =
+@inline stat_namedtuple(s::MDB_stat) =
     (psize          = Int(s.ms_psize),
      depth          = Int(s.ms_depth),
      branch_pages   = Int(s.ms_branch_pages),

src/cursor.jl

@@ -76,35 +76,35 @@ Base.show(io::IO, cur::Cursor) =
 # Populate `key_ref` with `searchkey`'s data. Returns the heap-rooted argument
 # that the caller must keep alive across the surrounding ccall (use
 # `GC.@preserve`); the pointer baked into `key_ref` aliases its data.
-@inline function _setup_key!(key_ref, k::String)
+@inline function setup_key!(key_ref, k::String)
     key_ref[] = MDB_val(Csize_t(sizeof(k)),
                          Ptr{Cvoid}(Base.unsafe_convert(Ptr{UInt8}, k)))
     return k
 end
-@inline function _setup_key!(key_ref, k::AbstractArray{T}) where {T}
+@inline function setup_key!(key_ref, k::AbstractArray{T}) where {T}
     key_ref[] = MDB_val(Csize_t(sizeof(T) * length(k)),
                          Ptr{Cvoid}(Base.unsafe_convert(Ptr{T}, k)))
     return k
 end
-@inline function _setup_key!(key_ref, k::Base.RefValue{T}) where {T}
+@inline function setup_key!(key_ref, k::Base.RefValue{T}) where {T}
     key_ref[] = MDB_val(Csize_t(sizeof(T)),
                          Ptr{Cvoid}(Base.unsafe_convert(Ptr{T}, k)))
     return k
 end
-@inline function _setup_key!(key_ref, k::T) where T
-    isbitstype(T) || throw(MethodError(_setup_key!, (key_ref, k)))
-    return _setup_key!(key_ref, Ref(k))
+@inline function setup_key!(key_ref, k::T) where T
+    isbitstype(T) || throw(MethodError(setup_key!, (key_ref, k)))
+    return setup_key!(key_ref, Ref(k))
 end
 
 # Position the cursor with `op`. Returns `true` on success, `false` on
 # `MDB_NOTFOUND`. Throws on other errors.
-@inline function _cursor_seek!(cur::Cursor, key_ref::Ref{MDB_val},
+@inline function cursor_seek!(cur::Cursor, key_ref::Ref{MDB_val},
                                val_ref::Ref{MDB_val}, op::MDB_cursor_op,
                                searchkey)
     if searchkey === nothing
         ret = unchecked_mdb_cursor_get(cur, key_ref, val_ref, op)
     else
-        held = _setup_key!(key_ref, searchkey)
+        held = setup_key!(key_ref, searchkey)
         ret = GC.@preserve held unchecked_mdb_cursor_get(cur, key_ref, val_ref, op)
     end
     ret == MDB_NOTFOUND && return false
@@ -119,8 +119,9 @@ Position the cursor at the first entry. Returns the key as `T`, or `nothing`
 if the database is empty. Wraps `MDB_FIRST`.
 """
 function seek!(cur::Cursor, ::Type{T}=Vector{UInt8}) where T
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_FIRST, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_FIRST, nothing) || return nothing
     return Base.read(MDBValueIO(key_ref[]), T)
 end
 
@@ -131,8 +132,9 @@ Position the cursor at the entry whose key exactly equals `key`. Returns the
 matched key as `T`, or `nothing` if no such entry exists. Wraps `MDB_SET_KEY`.
 """
 function seek!(cur::Cursor, searchkey, ::Type{T}=Vector{UInt8}) where T
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_SET_KEY, searchkey) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_SET_KEY, searchkey) || return nothing
     return Base.read(MDBValueIO(key_ref[]), T)
 end
 
@@ -143,8 +145,9 @@ Position the cursor at the last entry. Returns the key as `T`, or `nothing`
 if the database is empty. Wraps `MDB_LAST`.
 """
 function seek_last!(cur::Cursor, ::Type{T}=Vector{UInt8}) where T
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_LAST, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_LAST, nothing) || return nothing
     return Base.read(MDBValueIO(key_ref[]), T)
 end
 
@@ -155,8 +158,9 @@ Position the cursor at the smallest key `>= key`. Returns the matched key as
 `T`, or `nothing` if no such entry exists. Wraps `MDB_SET_RANGE`.
 """
 function seek_range!(cur::Cursor, searchkey, ::Type{T}=Vector{UInt8}) where T
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_SET_RANGE, searchkey) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_SET_RANGE, searchkey) || return nothing
     return Base.read(MDBValueIO(key_ref[]), T)
 end
 
@@ -167,8 +171,9 @@ Advance the cursor by one entry. Returns the new key as `T`, or `nothing` if
 the cursor moved past the last entry. Wraps `MDB_NEXT`.
 """
 function next!(cur::Cursor, ::Type{T}=Vector{UInt8}) where T
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_NEXT, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_NEXT, nothing) || return nothing
     return Base.read(MDBValueIO(key_ref[]), T)
 end
 
@@ -179,8 +184,9 @@ Move the cursor back by one entry. Returns the new key as `T`, or `nothing`
 if the cursor moved past the first entry. Wraps `MDB_PREV`.
 """
 function prev!(cur::Cursor, ::Type{T}=Vector{UInt8}) where T
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_PREV, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_PREV, nothing) || return nothing
     return Base.read(MDBValueIO(key_ref[]), T)
 end
 
@@ -191,7 +197,8 @@ Return the key at the cursor's current position, decoded as `K`. Wraps
 `MDB_GET_CURRENT`. Throws if the cursor is not positioned.
 """
 function key(cur::Cursor, ::Type{K}=Vector{UInt8}) where K
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
     mdb_cursor_get(cur, key_ref, val_ref, MDB_GET_CURRENT)
     return Base.read(MDBValueIO(key_ref[]), K)
 end
@@ -203,7 +210,8 @@ Return the value at the cursor's current position, decoded as `V`. Wraps
 `MDB_GET_CURRENT`. Throws if the cursor is not positioned.
 """
 function value(cur::Cursor, ::Type{V}=Vector{UInt8}) where V
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
     mdb_cursor_get(cur, key_ref, val_ref, MDB_GET_CURRENT)
     return Base.read(MDBValueIO(val_ref[]), V)
 end
@@ -215,7 +223,8 @@ Return the (key => value) pair at the cursor's current position. Wraps
 `MDB_GET_CURRENT`.
 """
 function item(cur::Cursor, ::Type{K}=Vector{UInt8}, ::Type{V}=Vector{UInt8}) where {K,V}
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
     mdb_cursor_get(cur, key_ref, val_ref, MDB_GET_CURRENT)
     return Base.read(MDBValueIO(key_ref[]), K) => Base.read(MDBValueIO(val_ref[]), V)
 end
@@ -228,8 +237,9 @@ value as `V`, or `nothing` if the current entry has no duplicates. Wraps
 `MDB_FIRST_DUP`. Only meaningful in `MDB_DUPSORT` databases.
 """
 function seek_first_dup!(cur::Cursor, ::Type{V}=Vector{UInt8}) where V
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_FIRST_DUP, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_FIRST_DUP, nothing) || return nothing
     return Base.read(MDBValueIO(val_ref[]), V)
 end
 
@@ -241,8 +251,9 @@ value as `V`, or `nothing` if the current entry has no duplicates. Wraps
 `MDB_LAST_DUP`.
 """
 function seek_last_dup!(cur::Cursor, ::Type{V}=Vector{UInt8}) where V
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_LAST_DUP, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_LAST_DUP, nothing) || return nothing
     return Base.read(MDBValueIO(val_ref[]), V)
 end
 
@@ -254,8 +265,9 @@ as `V`, or `nothing` if there are no more duplicates of this key. Wraps
 `MDB_NEXT_DUP`.
 """
 function next_dup!(cur::Cursor, ::Type{V}=Vector{UInt8}) where V
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_NEXT_DUP, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_NEXT_DUP, nothing) || return nothing
     return Base.read(MDBValueIO(val_ref[]), V)
 end
 
@@ -267,8 +279,9 @@ as `V`, or `nothing` if there are no earlier duplicates. Wraps
 `MDB_PREV_DUP`.
 """
 function prev_dup!(cur::Cursor, ::Type{V}=Vector{UInt8}) where V
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_PREV_DUP, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_PREV_DUP, nothing) || return nothing
     return Base.read(MDBValueIO(val_ref[]), V)
 end
 
@@ -280,8 +293,9 @@ of the current key. Returns the new key as `K`, or `nothing` past the last
 key. Wraps `MDB_NEXT_NODUP`.
 """
 function next_nodup!(cur::Cursor, ::Type{K}=Vector{UInt8}) where K
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_NEXT_NODUP, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_NEXT_NODUP, nothing) || return nothing
     return Base.read(MDBValueIO(key_ref[]), K)
 end
 
@@ -292,8 +306,9 @@ Move to the last entry of the previous key. Returns the new key as `K`, or
 `nothing` past the first key. Wraps `MDB_PREV_NODUP`.
 """
 function prev_nodup!(cur::Cursor, ::Type{K}=Vector{UInt8}) where K
-    key_ref = Ref(MDBValue()); val_ref = Ref(MDBValue())
-    _cursor_seek!(cur, key_ref, val_ref, MDB_PREV_NODUP, nothing) || return nothing
+    key_ref = Ref(MDBValue())
+    val_ref = Ref(MDBValue())
+    cursor_seek!(cur, key_ref, val_ref, MDB_PREV_NODUP, nothing) || return nothing
     return Base.read(MDBValueIO(key_ref[]), K)
 end
 
@@ -316,7 +331,7 @@ function walk(f, cur::Cursor; from = nothing)
     if from === nothing
         ret = unchecked_mdb_cursor_get(cur, key_ref, val_ref, MDB_FIRST)
     else
-        held = _setup_key!(key_ref, from)
+        held = setup_key!(key_ref, from)
         ret = GC.@preserve held unchecked_mdb_cursor_get(cur, key_ref, val_ref,
                                                           MDB_SET_RANGE)
     end

src/database.jl

@@ -137,7 +137,7 @@ Live byte usage = `(branch_pages + leaf_pages + overflow_pages) * psize`.
 function stat(txn::Transaction, dbi::DBI)
     s_ref = Ref{MDB_stat}()
     mdb_stat(txn, dbi, s_ref)
-    return _stat_namedtuple(s_ref[])
+    return stat_namedtuple(s_ref[])
 end
 
 """Get an item from a database. Throws `LMDBError` if `key` is not present."""

src/dictionary.jl

@@ -67,7 +67,7 @@ function txn_dbi_do(f, d; readonly = false)
     end
 end
 
-@inline function _has_prefix(kv::LMDB.MDB_val, prefix::Vector{UInt8})
+@inline function has_prefix(kv::LMDB.MDB_val, prefix::Vector{UInt8})
     kv.mv_size < length(prefix) && return false
     p = Ptr{UInt8}(kv.mv_data)
     @inbounds for i in 1:length(prefix)
@@ -76,12 +76,12 @@ end
     return true
 end
 
-function _walk_prefix(f, cur, prefix::Vector{UInt8})
+function walk_prefix(f, cur, prefix::Vector{UInt8})
     if isempty(prefix)
         LMDB.walk(f, cur)
     else
         LMDB.walk(cur; from = prefix) do k_ref, v_ref
-            _has_prefix(k_ref[], prefix) || return false
+            has_prefix(k_ref[], prefix) || return false
             f(k_ref, v_ref)
             return nothing
         end
@@ -98,13 +98,13 @@ end
 function Base.iterate(d::LMDBDict)
     txn = LMDB.start(d.env; flags = Cuint(MDB_RDONLY))
     cur = LMDB.open(txn, d.dbi)
-    return _iter_step(d, txn, cur, MDB_FIRST)
+    return iter_step(d, txn, cur, MDB_FIRST)
 end
 Base.iterate(d::LMDBDict, (txn, cur)::Tuple{Transaction,Cursor}) =
-    _iter_step(d, txn, cur, MDB_NEXT)
+    iter_step(d, txn, cur, MDB_NEXT)
 
-function _iter_step(::LMDBDict{K,V}, txn::Transaction, cur::Cursor,
-                    op::MDB_cursor_op) where {K,V}
+function iter_step(::LMDBDict{K,V}, txn::Transaction, cur::Cursor,
+                   op::MDB_cursor_op) where {K,V}
     k_ref = Ref(MDBValue())
     v_ref = Ref(MDBValue())
     ret = LMDB.unchecked_mdb_cursor_get(cur, k_ref, v_ref, op)
@@ -273,7 +273,8 @@ function Base.filter!(f, d::LMDBDict{K,V}) where {K,V}
     return d
 end
 
-# --- prefix-scan helpers (LMDB-namespaced; not Base extensions) ---
+
+# --- prefix-scan helpers ---
 
 """
     scan(d::LMDBDict; prefix=UInt8[]) -> Vector{Pair{K,V}}
@@ -286,7 +287,7 @@ function scan(d::LMDBDict{K,V}; prefix = UInt8[]) where {K,V}
     bprefix = Vector{UInt8}(prefix)
     out = Pair{K,V}[]
     cursor_do(d, readonly = true) do cur
-        _walk_prefix(cur, bprefix) do k_ref, v_ref
+        walk_prefix(cur, bprefix) do k_ref, v_ref
             push!(out, Base.read(MDBValueIO(k_ref[]), K) =>
                        Base.read(MDBValueIO(v_ref[]), V))
         end
@@ -303,7 +304,7 @@ function scan_keys(d::LMDBDict{K}; prefix = UInt8[]) where K
     bprefix = Vector{UInt8}(prefix)
     out = K[]
     cursor_do(d, readonly = true) do cur
-        _walk_prefix(cur, bprefix) do k_ref, _
+        walk_prefix(cur, bprefix) do k_ref, _
             push!(out, Base.read(MDBValueIO(k_ref[]), K))
         end
     end
@@ -319,7 +320,7 @@ function scan_values(d::LMDBDict{K,V}; prefix = UInt8[]) where {K,V}
     bprefix = Vector{UInt8}(prefix)
     out = V[]
     cursor_do(d, readonly = true) do cur
-        _walk_prefix(cur, bprefix) do _, v_ref
+        walk_prefix(cur, bprefix) do _, v_ref
             push!(out, Base.read(MDBValueIO(v_ref[]), V))
         end
     end
@@ -367,7 +368,7 @@ function valuesize(d::LMDBDict; prefix = UInt8[])
     bprefix = Vector{UInt8}(prefix)
     total = 0
     cursor_do(d, readonly = true) do cur
-        _walk_prefix(cur, bprefix) do _, v_ref
+        walk_prefix(cur, bprefix) do _, v_ref
             total += Int(v_ref[].mv_size)
         end
     end