Rename DBI to Database, qualify demoted names in tests.

`Database` reads better than the C-flavoured `DBI`. The struct, all
its method signatures, and every prose mention switch over. The
underlying `MDB_dbi` Cuint type (the C ABI) is unchanged; only the
Julia wrapper renames.

While here, switch the tests from bare names to the `LMDB.X`
qualification that user code actually sees after the recent export
demotion. `LMDBDict` / `LMDBError` stay unprefixed (still exported);
`LMDB.Environment`, `LMDB.Transaction`, `LMDB.Database`, `LMDB.Cursor`,
and the env operations (`LMDB.set!`, `LMDB.unset!`, `LMDB.sync`,
`LMDB.info`, `LMDB.reader_check`, `LMDB.reader_list`) gain the prefix.
The earlier `using LMDB: ...` hack in runtests.jl is gone.

Author: maleadt

README.md

@@ -22,7 +22,7 @@ LMDB.jl exposes the same database through three surfaces:
   `AbstractDict{K,V}` over a single LMDB file. Standard library
   machinery (`merge!`, `filter!`, `pairs`, iteration, …) works out
   of the box. Reach for this when you want a persistent `Dict`.
-- Julia wrappers: `Environment`, `Transaction`, `DBI`, `Cursor`.
+- Julia wrappers: `Environment`, `Transaction`, `Database`, `Cursor`.
   Julia-shaped wrappers around handles, transactions, and cursors,
   with finalizers, `do`-block forms, and so on. Use these when you
   want explicit transactions.

docs/src/index.md

@@ -18,7 +18,7 @@ LMDB.jl exposes the same database through three surfaces:
 | Surface | What it offers | When to use |
 |---------|----------------|-------------|
 | High-level interface | `LMDBDict <: AbstractDict{K,V}` | When you want a persistent `Dict`. |
-| Julia wrappers | `Environment`, `Transaction`, `DBI`, `Cursor` | When you want explicit transactions and cursors with Julia-shaped wrappers. |
+| Julia wrappers | `Environment`, `Transaction`, `Database`, `Cursor` | When you want explicit transactions and cursors with Julia-shaped wrappers. |
 | C API | `LMDB.mdb_*`, `LMDB.MDB_*` | Raw `ccall` bindings and status-code constants, for custom data layouts or when you want to skip allocations on hot paths. |
 
 `MDBValue`, `MDBArg`, and the [`MDBValueIO`](@ref LMDB.MDBValueIO)

docs/src/lib/cursors.md

@@ -4,14 +4,14 @@
 CurrentModule = LMDB
 ```
 
-A `Cursor` is a positioned iterator over the entries in a `DBI`. Cursors
+A `Cursor` is a positioned iterator over the entries in a `Database`. Cursors
 are bound to a transaction. Closing the txn invalidates the cursor.
 
 ## Construction
 
 ```@docs
 Cursor
-Cursor(::Transaction, ::DBI)
+Cursor(::Transaction, ::Database)
 Base.close(::Cursor)
 Base.isopen(::Cursor)
 renew(::Transaction, ::Cursor)

docs/src/lib/databases.md

@@ -1,31 +1,31 @@
-# [Databases](@id API-DBI)
+# [Databases](@id API-Database)
 
 ```@meta
 CurrentModule = LMDB
 ```
 
-A `DBI` (database identifier) is a handle to one B-tree inside an
+A `Database` (database identifier) is a handle to one B-tree inside an
 environment. By default an env has a single anonymous database (the
-"main DB"); pass `maxdbs > 0` to `Environment` and a name to the `DBI`
+"main DB"); pass `maxdbs > 0` to `Environment` and a name to the `Database`
 constructor to work with multiple named sub-databases.
 
 ## Construction
 
 ```@docs
-DBI
-DBI(::Transaction, ::AbstractString)
-Base.close(::Environment, ::DBI)
-Base.isopen(::DBI)
+Database
+Database(::Transaction, ::AbstractString)
+Base.close(::Environment, ::Database)
+Base.isopen(::Database)
 flags
 drop
-Base.stat(::Transaction, ::DBI)
+Base.stat(::Transaction, ::Database)
 ```
 
 ## Reads
 
 ```@docs
-Base.get(::Transaction, ::DBI, ::Any, ::Type{T}) where T
-Base.get(::Transaction, ::DBI, ::Any, ::Type{T}, ::Any) where T
+Base.get(::Transaction, ::Database, ::Any, ::Type{T}) where T
+Base.get(::Transaction, ::Database, ::Any, ::Type{T}, ::Any) where T
 ```
 
 `get(txn, dbi, key, T, default)` falls back to `default` if `key` is
@@ -34,11 +34,11 @@ missing, matching `Base.get(dict, key, default)`.
 ## Writes
 
 ```@docs
-Base.put!(::Transaction, ::DBI, ::Any, ::Any)
+Base.put!(::Transaction, ::Database, ::Any, ::Any)
 put_reserved!
-Base.delete!(::Transaction, ::DBI, ::Any)
-Base.replace!(::Transaction, ::DBI, ::Any, ::Any)
-Base.pop!(::Transaction, ::DBI, ::Any, ::Type)
+Base.delete!(::Transaction, ::Database, ::Any)
+Base.replace!(::Transaction, ::Database, ::Any, ::Any)
+Base.pop!(::Transaction, ::Database, ::Any, ::Type)
 ```
 
 ## Write flags

docs/src/lib/dict.md

@@ -32,7 +32,7 @@ Everything `AbstractDict` derives (`merge!`, `merge`, `mergewith!`,
 
 ## Lifecycle
 
-`close(::LMDBDict)` closes the underlying env (and the default DBI).
+`close(::LMDBDict)` closes the underlying env (and the default Database).
 Idempotent, and also called from the finalizer.
 
 ## Prefix-scan helpers

docs/src/lib/lowlevel.md

@@ -107,7 +107,7 @@ mdb_txn_reset
 mdb_txn_renew
 ```
 
-### Database (DBI)
+### Database (Database)
 
 ```julia
 mdb_dbi_open

docs/src/man/cursors.md

@@ -4,15 +4,15 @@
 CurrentModule = LMDB
 ```
 
-A `Cursor` is a positioned iterator over a `DBI`. Use it for ordered
+A `Cursor` is a positioned iterator over a `Database`. Use it for ordered
 scans, range queries, or to amortise the per-lookup overhead of
 `mdb_get` across many keys.
 
 ## Opening a cursor
 
 ```julia
 Transaction(env; flags = LMDB.MDB_RDONLY) do txn
-    DBI(txn) do dbi
+    Database(txn) do dbi
         Cursor(txn, dbi) do cur
             # use cur
         end
@@ -67,7 +67,7 @@ A typical pattern for "all keys with a given prefix":
 ```julia
 prefix = "users/"
 Transaction(env; flags = LMDB.MDB_RDONLY) do txn
-    DBI(txn) do dbi
+    Database(txn) do dbi
         Cursor(txn, dbi) do cur
             k = seek_range!(cur, prefix, String)
             while k !== nothing && startswith(k, prefix)

docs/src/man/databases.md

@@ -4,31 +4,31 @@
 CurrentModule = LMDB
 ```
 
-A `DBI` is a handle to one B-tree inside an environment. By default an
+A `Database` is a handle to one B-tree inside an environment. By default an
 env has a single anonymous database (the "main DB"); pass `maxdbs > 0`
 to `Environment` to support multiple named sub-databases.
 
-## Opening a DBI
+## Opening a Database
 
 ```julia
-dbi = DBI(txn)                      # main (unnamed) DB
-dbi = DBI(txn, "users")             # named sub-DB; needs maxdbs >= 1
-dbi = DBI(txn, "edges"; flags = LMDB.MDB_CREATE | LMDB.MDB_DUPSORT)
+dbi = Database(txn)                      # main (unnamed) DB
+dbi = Database(txn, "users")             # named sub-DB; needs maxdbs >= 1
+dbi = Database(txn, "edges"; flags = LMDB.MDB_CREATE | LMDB.MDB_DUPSORT)
 ```
 
-The do-block form closes the DBI on the way out:
+The do-block form closes the Database on the way out:
 
 ```julia
-DBI(txn, "users") do dbi
+Database(txn, "users") do dbi
     put!(txn, dbi, "1", "Ada")
 end
 ```
 
-In practice you'll rarely *want* to close a DBI handle explicitly. The
+In practice you'll rarely *want* to close a Database handle explicitly. The
 env owns it, and `mdb_dbi_close` is documented as rarely useful. The
-env's finalizer cascades through any open DBI handles.
+env's finalizer cascades through any open Database handles.
 
-## DBI flags
+## Database flags
 
 `flags` accepts a bitwise-or of:
 
@@ -86,7 +86,7 @@ Useful write flags:
 ```julia
 # Bulk import in sorted order:
 Transaction(env) do txn
-    DBI(txn) do dbi
+    Database(txn) do dbi
         for (k, v) in sorted_pairs
             put!(txn, dbi, k, v; flags = LMDB.MDB_APPEND)
         end

docs/src/man/dict.md

@@ -5,7 +5,7 @@ CurrentModule = LMDB
 ```
 
 `LMDBDict{K,V}` is a persistent `AbstractDict{K,V}` backed by a single
-LMDB environment plus the default DBI. Open it, treat it like a `Dict`,
+LMDB environment plus the default Database. Open it, treat it like a `Dict`,
 close it.
 
 ## Construction

docs/src/man/dupsort.md

@@ -13,7 +13,7 @@ values" patterns.
 ```julia
 env = Environment("/tmp/edges"; mapsize = 1 << 30, maxdbs = 1)
 Transaction(env) do txn
-    dbi = DBI(txn, "edges"; flags = LMDB.MDB_CREATE | LMDB.MDB_DUPSORT)
+    dbi = Database(txn, "edges"; flags = LMDB.MDB_CREATE | LMDB.MDB_DUPSORT)
     put!(txn, dbi, "a", "b")
     put!(txn, dbi, "a", "c")
     put!(txn, dbi, "a", "d")