tests: Tests for open, put, get and delete

Author: gcarreno

.gitignore

@@ -1,5 +1,6 @@
 # LevelDB project specific
 /bin
+test.db
 
 # Compiled l10n files: .mo should be ignored
 *.mo

research/ChatGPT-LevelDB-Class-Extended.md

@@ -0,0 +1,273 @@
+# Prompt
+
+With this extended version of the header translation can you please update the wrapper class example from before?
+
+# Answer
+
+Sure! Below is an updated implementation of the wrapper class that incorporates the extended header translation for `LevelDB`, including support for the additional features we just added (Bloom filters, caching, etc.).
+
+### Updated LevelDB Wrapper Class
+
+Here’s the updated wrapper class in Free Pascal that reflects the extended header translation:
+
+```pascal
+unit LevelDBWrapper;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  leveldb_extended, sysutils, ctypes;
+
+type
+  TLevelDBWrapper = class
+  private
+    FDB: Pleveldb_t;
+    FOptions: Pleveldb_options_t;
+    FReadOptions: Pleveldb_readoptions_t;
+    FWriteOptions: Pleveldb_writeoptions_t;
+    FCache: Pleveldb_cache_t;
+    FFilterPolicy: Pleveldb_filterpolicy_t;
+    procedure InitDB(const APath: string);
+    procedure FreeResources;
+  public
+    constructor Create(const APath: string);
+    destructor Destroy; override;
+
+    function Put(const AKey, AValue: string): Boolean;
+    function Get(const AKey: string; out AValue: string): Boolean;
+    function Delete(const AKey: string): Boolean;
+    procedure WriteBatch(const ABatch: array of record Key: string; Value: string end);
+    procedure Iterate;
+
+    // Options setters
+    procedure SetCompression(ACompression: cint);
+    procedure SetBloomFilter(AFilterBitsPerKey: cint);
+    procedure SetCache(ACacheSize: cint);
+  end;
+
+implementation
+
+constructor TLevelDBWrapper.Create(const APath: string);
+begin
+  inherited Create;
+  InitDB(APath);
+end;
+
+destructor TLevelDBWrapper.Destroy;
+begin
+  FreeResources;
+  inherited Destroy;
+end;
+
+procedure TLevelDBWrapper.InitDB(const APath: string);
+begin
+  FOptions := leveldb_options_create;
+  leveldb_options_set_create_if_missing(FOptions, True);
+  FCache := leveldb_cache_create_lru(1024 * 1024); // Default: 1MB cache
+  leveldb_options_set_cache(FOptions, FCache);
+
+  // Open the database
+  FDB := leveldb_open(FOptions, PChar(APath), nil);
+  if FDB = nil then
+    raise Exception.Create('Failed to open LevelDB at ' + APath);
+
+  // Initialize read and write options
+  FReadOptions := leveldb_readoptions_create;
+  FWriteOptions := leveldb_writeoptions_create;
+end;
+
+procedure TLevelDBWrapper.FreeResources;
+begin
+  leveldb_close(FDB);
+  leveldb_readoptions_destroy(FReadOptions);
+  leveldb_writeoptions_destroy(FWriteOptions);
+  leveldb_cache_destroy(FCache);
+  leveldb_options_destroy(FOptions);
+end;
+
+function TLevelDBWrapper.Put(const AKey, AValue: string): Boolean;
+var
+  Err: PChar;
+begin
+  Result := leveldb_put(FDB, FWriteOptions, PChar(AKey), Length(AKey), PChar(AValue), Length(AValue), Err) = LEVELDB_OK;
+  if Err <> nil then
+  begin
+    WriteLn('Error putting value: ', StrPas(Err));
+    leveldb_free(Err);
+  end;
+end;
+
+function TLevelDBWrapper.Get(const AKey: string; out AValue: string): Boolean;
+var
+  ValPtr: PChar;
+  ValLen: csize_t;
+  Err: PChar;
+begin
+  ValPtr := leveldb_get(FDB, FReadOptions, PChar(AKey), Length(AKey), ValLen, Err);
+  if Err <> nil then
+  begin
+    WriteLn('Error getting value: ', StrPas(Err));
+    leveldb_free(Err);
+    Result := False;
+    Exit;
+  end;
+
+  SetString(AValue, ValPtr, ValLen);
+  leveldb_free(ValPtr);
+  Result := True;
+end;
+
+function TLevelDBWrapper.Delete(const AKey: string): Boolean;
+var
+  Err: PChar;
+begin
+  Result := leveldb_delete(FDB, FWriteOptions, PChar(AKey), Length(AKey), Err) = LEVELDB_OK;
+  if Err <> nil then
+  begin
+    WriteLn('Error deleting value: ', StrPas(Err));
+    leveldb_free(Err);
+  end;
+end;
+
+procedure TLevelDBWrapper.WriteBatch(const ABatch: array of record Key: string; Value: string end);
+var
+  Batch: Pleveldb_writebatch_t;
+  i: Integer;
+  Err: PChar;
+begin
+  Batch := leveldb_writebatch_create;
+  try
+    for i := Low(ABatch) to High(ABatch) do
+    begin
+      leveldb_writebatch_put(Batch, PChar(ABatch[i].Key), Length(ABatch[i].Key), PChar(ABatch[i].Value), Length(ABatch[i].Value));
+    end;
+    leveldb_write(FDB, FWriteOptions, Batch, Err);
+    if Err <> nil then
+    begin
+      WriteLn('Error writing batch: ', StrPas(Err));
+      leveldb_free(Err);
+    end;
+  finally
+    leveldb_writebatch_destroy(Batch);
+  end;
+end;
+
+procedure TLevelDBWrapper.Iterate;
+var
+  Iterator: Pleveldb_iterator_t;
+  Key: PChar;
+  Value: PChar;
+  KeyLen, ValueLen: csize_t;
+begin
+  Iterator := leveldb_create_iterator(FDB, FReadOptions);
+  try
+    leveldb_iter_seek_to_first(Iterator);
+    while leveldb_iter_valid(Iterator) do
+    begin
+      Key := leveldb_iter_key(Iterator, KeyLen);
+      Value := leveldb_iter_value(Iterator, ValueLen);
+      WriteLn('Key: ', StrPas(Key), ', Value: ', StrPas(Value));
+      leveldb_iter_next(Iterator);
+    end;
+  finally
+    leveldb_iter_destroy(Iterator);
+  end;
+end;
+
+// Options setters
+procedure TLevelDBWrapper.SetCompression(ACompression: cint);
+begin
+  leveldb_options_set_compression(FOptions, ACompression);
+end;
+
+procedure TLevelDBWrapper.SetBloomFilter(AFilterBitsPerKey: cint);
+begin
+  FFilterPolicy := leveldb_filterpolicy_create_bloom(AFilterBitsPerKey);
+  leveldb_options_set_filter_policy(FOptions, FFilterPolicy);
+end;
+
+procedure TLevelDBWrapper.SetCache(ACacheSize: cint);
+begin
+  FCache := leveldb_cache_create_lru(ACacheSize);
+  leveldb_options_set_cache(FOptions, FCache);
+end;
+
+end.
+```
+
+### Key Features of the Updated Wrapper Class
+
+1. **Initialization**:
+   - The constructor initializes the database, options, and caching mechanism.
+   - The Bloom filter policy can be set using `SetBloomFilter`.
+
+2. **CRUD Operations**:
+   - `Put`, `Get`, and `Delete` methods handle adding, retrieving, and removing key-value pairs from the database.
+   - Each method checks for errors and prints appropriate messages if something goes wrong.
+
+3. **Batch Operations**:
+   - The `WriteBatch` method allows for batch inserts, where you can add multiple key-value pairs in a single operation.
+
+4. **Iteration**:
+   - The `Iterate` method lets you traverse all key-value pairs in the database.
+
+5. **Options Setters**:
+   - Methods to set compression options, Bloom filter, and cache size are provided to customize the database behavior.
+
+### Usage Example
+
+Here's how you could use this wrapper class in your program:
+
+```pascal
+program LevelDBWrapperExample;
+
+{$mode objfpc}{$H+}
+
+uses
+  LevelDBWrapper, sysutils;
+
+var
+  DB: TLevelDBWrapper;
+  Value: string;
+begin
+  try
+    DB := TLevelDBWrapper.Create('testdb');
+    try
+      // Put some values
+      DB.Put('key1', 'value1');
+      DB.Put('key2', 'value2');
+
+      // Get a value
+      if DB.Get('key1', Value) then
+        WriteLn('Retrieved: key1 = ', Value);
+
+      // Delete a key
+      if DB.Delete('key2') then
+        WriteLn('Deleted key2.');
+
+      // Write a batch
+      DB.WriteBatch([
+        (Key: 'key3'; Value: 'value3'),
+        (Key: 'key4'; Value: 'value4')
+      ]);
+
+      // Iterate through the database
+      DB.Iterate;
+    finally
+      DB.Free;
+    end;
+  except
+    on E: Exception do
+      Writeln('Error: ', E.Message);
+  end;
+end.
+```
+
+### Explanation of the Example Usage:
+- Creates an instance of `TLevelDBWrapper` pointing to a database at `testdb`.
+- Demonstrates the `Put`, `Get`, `Delete`, and `WriteBatch` functionalities.
+- Calls `Iterate` to print all key-value pairs in the database.
+
+This should give you a solid foundation for using LevelDB in your Free Pascal projects with a structured and organized approach. If you have any other modifications or features you want to include, feel free to ask!