mdbxmou 0.1.26

package/test/e5.js

@@ -0,0 +1,162 @@
+"use strict";
+
+const fs = require('fs');
+const MDBX = require('../lib/nativemou.js');
+const { MDBX_Env, MDBX_Param } = MDBX;
+
+const test = async () => {
+  const path = 'e5';
+
+  await Promise.all([
+    fs.promises.rm(path, { recursive: true, force: true })
+  ]);
+
+  console.log("MDBX_Param:", MDBX_Param);
+  // получаем константы
+  const { keyMode, keyFlag, queryMode, valueFlag } = MDBX_Param;
+
+  const db = new MDBX_Env();
+
+  console.log('Opening database...');
+  const rc = await db.open({
+      path: path,
+      valueFlag: valueFlag.string
+  });
+
+  const count = 2;
+  console.log('Start write');
+  const txn = db.startWrite();
+  // будем использовать ordinal ключи
+  const dbi = txn.createMap(keyMode.ordinal);
+  for (let i = 0; i < count; i++) {
+    dbi.put(i, `val-${i}`, 0);
+  }
+  txn.commit();
+  console.log('Write finish');
+
+  // вычитаем key = 1 - асинхронно
+  // запишем при этом key = 2
+  // по умолчаниюю query выполняется в режиме wr
+  const out = await db.query([
+    { 
+      mode: queryMode.get, 
+      keyMode: keyMode.ordinal, 
+      keyFlag: keyFlag.number,
+      item: [{ "key": 1 }, { "key": 42 }] 
+    },
+    { 
+      mode: queryMode.insertUnique, 
+      keyMode: keyMode.ordinal,
+      keyFlag: keyFlag.number,
+      item: [{ "key": 2, "value":"val-2" }] 
+    }
+  ]);
+  console.log('q1', JSON.stringify(out));
+
+  // вычитаем key = 2 - синхронно
+  const r = db.startRead();
+  const rdbi = r.openMap(keyMode.ordinal);
+  const keys = rdbi.keys();
+  const val = rdbi.get(2);
+  console.log("keys", keys);
+  console.log("read 2", val);
+
+  console.log("forEach");
+  rdbi.forEach((key, value, index) => {
+    console.log(`[${index}]`, key, value);
+  });
+
+  console.log("forEach from key 1");
+  rdbi.forEach(1, (key, value, index) => {
+    console.log(`[${index}]`, key, value);
+  });
+
+  {
+    const out = rdbi.keysFrom(1);
+    console.log("keysFrom()", out);
+  }  
+
+  r.commit();
+
+  {
+    // почитаем асинхронно в упрощенном режиме
+    console.log("Read key = 2 in simple async mode to out2");
+    const out2 = await db.query({
+      keyMode: keyMode.ordinal,
+      item: [{ "key": 2 }, { "key": 42 }]  
+    });
+    console.log("out2", JSON.stringify(out2));
+  }
+  
+  {
+    // почитаем асинхронно в упрощенном режиме
+    const out = await db.keys({
+      keyMode: BigInt(keyMode.ordinal),
+    });
+    console.log("await keys()", out);
+  }
+
+  // добавим не существующий ключ
+  keys.push(42);
+  // удалим все ключи
+  const rm = await db.query([
+      { 
+        mode: queryMode.del, 
+        keyMode: keyMode.ordinal, 
+        item: keys.map(key => ({ "key": key }))
+      }
+  ]);
+  console.log("rm keys", JSON.stringify(rm));
+
+  // Тестируем forEach с cursorMode
+  {
+    console.log("=== Testing forEach with cursorMode ===");
+    
+    // добавим тестовые данные
+    const w = db.startWrite();
+    const wdbi = w.createMap(keyMode.ordinal);
+    for (let i = 1; i <= 10; i++) {
+      wdbi.put(i, `value${i}`);
+    }
+    w.commit();
+    
+    // читаем заново
+    const r = db.startRead();
+    const dbi = r.openMap(keyMode.ordinal);
+    
+    // forEach(fn) - обычный вызов
+    console.log("forEach(fn):");
+    dbi.forEach((k, v, i) => {
+      console.log(`  ${i}: ${k} = ${v}`);
+      return i >= 2; // останавливаем после 3 элементов
+    });
+    
+    // forEach(fromKey, fn) - с начального ключа
+    console.log("forEach(fromKey=5, fn):");
+    dbi.forEach(5, (k, v, i) => {
+      console.log(`  ${i}: ${k} = ${v}`);
+      return i >= 2; // останавливаем после 3 элементов
+    });
+    
+    // forEach(fromKey, cursorMode, fn) - с cursorMode
+    console.log("forEach(fromKey=7, cursorMode=keyGreater, fn):");
+    dbi.forEach(7, 'keyGreater', (k, v, i) => {
+      console.log(`  ${i}: ${k} = ${v}`);
+      return i >= 1; // останавливаем после 2 элементов
+    });
+    
+    r.commit();
+  }
+
+  // вычитаем все ключи
+  {
+    // вычитаем key = 2 - синхронно
+    const r = db.startRead();
+    const dbi = r.openMap(keyMode.ordinal);
+    console.log("keys", dbi.keys());
+    r.commit();
+  }
+  await db.close();
+}
+
+test().catch(console.error);

package/test/test-batch-ops.js

@@ -0,0 +1,243 @@
+"use strict";
+const fs = require("fs");
+const { MDBX_Async_Env } = require("../lib/mdbx_evn_async.js");
+const MDBX = require("../lib/nativemou.js");
+const { MDBX_Param } = MDBX;
+
+(async () => {
+  const testPath = "batch-ops-db";
+  await fs.promises.rm(testPath, { recursive: true, force: true }).catch(() => {});
+  
+  const env = new MDBX_Async_Env();
+  
+  try {
+    await env.open({ path: testPath });
+    const { keyMode } = MDBX_Param;
+
+    console.log("=== Тест групповых операций ===");
+    
+    // 1. Создаем транзакцию
+    console.log("1. Создаем транзакцию записи...");
+    const w = await env.startWrite();
+    const dbi = await w.openMap({ keyMode: keyMode.ordinal, create: true });
+    
+    // 2. Групповая запись множества ключей
+    console.log("2. Групповая запись 5 ключей...");
+    const itemsToWrite = [
+      { key: 1n, value: "value1" },
+      { key: 2n, value: "value2" },
+      { key: 3n, value: "value3" },
+      { key: 4n, value: "value4" },
+      { key: 5n, value: "value5" }
+    ];
+    
+    const writeResults = await dbi.putBatch(itemsToWrite);
+    console.log("Результат записи:", writeResults);
+    
+    // 3. Коммитим транзакцию
+    console.log("3. Коммитим транзакцию...");
+    await w.commit();
+    
+    // 4. Создаем транзакцию чтения
+    console.log("4. Создаем транзакцию чтения...");
+    const r = await env.startRead();
+    const readDbi = await r.openMap({ keyMode: keyMode.ordinal });
+    
+    // 5. Групповое чтение множества ключей
+    console.log("5. Групповое чтение ключей...");
+    const keysToRead = [1n, 2n, 3n, 42n, 5n]; // 42n не существует
+    const readResults = await readDbi.getBatch(keysToRead);
+    console.log("Результат чтения:");
+    readResults.forEach(r => {
+      console.log(`  Ключ ${r.key}: ${r.found ? r.value : 'НЕ НАЙДЕН'}`);
+    });
+    
+    await r.commit();
+    
+    // 6. Создаем транзакцию для удаления
+    console.log("6. Создаем транзакцию для удаления...");
+    const d = await env.startWrite();
+    const delDbi = await d.openMap({ keyMode: keyMode.ordinal });
+    
+    // 7. Групповое удаление ключей
+    console.log("7. Групповое удаление ключей...");
+    const keysToDelete = [2n, 4n, 42n]; // 42n не существует
+    const deleteResults = await delDbi.delBatch(keysToDelete);
+    console.log("Результат удаления:");
+    deleteResults.forEach(r => {
+      console.log(`  Ключ ${r.key}: ${r.deleted ? 'УДАЛЕН' : 'НЕ НАЙДЕН'}`);
+    });
+    
+    await d.commit();
+    
+    // 8. Проверяем финальное состояние
+    console.log("8. Проверяем финальное состояние...");
+    const final = await env.startRead();
+    const finalDbi = await final.openMap({ keyMode: keyMode.ordinal });
+    
+    const allKeys = [1n, 2n, 3n, 4n, 5n];
+    const finalResults = await finalDbi.getBatch(allKeys);
+    console.log("Финальное состояние:");
+    finalResults.forEach(r => {
+      console.log(`  Ключ ${r.key}: ${r.found ? r.value : 'ОТСУТСТВУЕТ'}`);
+    });
+    
+    await final.commit();
+    
+    await env.close();
+    console.log("Тест завершен успешно!");
+    
+    console.log("\n=== Тест с двумя базами данных ===");
+    
+    // Открываем заново для multi-database теста
+    await env.open({ path: testPath });
+    
+    // 1. Создаем транзакцию и две базы данных
+    console.log("1. Создаем транзакцию и две базы...");
+    const multiW = await env.startWrite();
+    const oddDbi = await multiW.openMap({ 
+      name: "odd_numbers", 
+      keyMode: keyMode.ordinal, 
+      create: true 
+    });
+    const evenDbi = await multiW.openMap({ 
+      name: "even_numbers", 
+      keyMode: keyMode.ordinal, 
+      create: true 
+    });
+    
+    // 2. Заполняем начальными данными
+    console.log("2. Заполняем начальными данными...");
+    const oddInitial = [
+      { key: 1n, value: "один" },
+      { key: 3n, value: "три" },
+      { key: 5n, value: "пять" }
+    ];
+    const evenInitial = [
+      { key: 2n, value: "два" },
+      { key: 4n, value: "четыре" }
+    ];
+    
+    const oddResults = await oddDbi.putBatch(oddInitial);
+    const evenResults = await evenDbi.putBatch(evenInitial);
+    
+    console.log("Нечетные числа записаны:", oddResults.every(r => r.success));
+    console.log("Четные числа записаны:", evenResults.every(r => r.success));
+    
+    // 3. Добавляем дополнительные данные в ту же транзакцию
+    console.log("3. Добавляем дополнительные числа...");
+    const oddAdditional = [
+      { key: 7n, value: "семь" },
+      { key: 9n, value: "девять" }
+    ];
+    const evenAdditional = [
+      { key: 6n, value: "шесть" },
+      { key: 8n, value: "восемь" }
+    ];
+    
+    await oddDbi.putBatch(oddAdditional);
+    await evenDbi.putBatch(evenAdditional);
+    
+    console.log("Дополнительные числа добавлены");
+    
+    // 4. Коммитим всё одной транзакцией
+    console.log("4. Коммитим обе базы одной транзакцией...");
+    await multiW.commit();
+    
+    // 5. Проверяем результаты в обеих базах
+    console.log("5. Проверяем результаты...");
+    const checkR = await env.startRead();
+    const checkOddDbi = await checkR.openMap({ 
+      name: "odd_numbers", 
+      keyMode: keyMode.ordinal 
+    });
+    const checkEvenDbi = await checkR.openMap({ 
+      name: "even_numbers", 
+      keyMode: keyMode.ordinal 
+    });
+    
+    // Читаем все нечетные числа
+    const oddKeys = [1n, 3n, 5n, 7n, 9n];
+    const oddFinalResults = await checkOddDbi.getBatch(oddKeys);
+    console.log("База нечетных чисел:");
+    oddFinalResults.forEach(r => {
+      console.log(`  ${r.key}: ${r.found ? r.value : 'ОТСУТСТВУЕТ'}`);
+    });
+    
+    // Читаем все четные числа
+    const evenKeys = [2n, 4n, 6n, 8n];
+    const evenFinalResults = await checkEvenDbi.getBatch(evenKeys);
+    console.log("База четных чисел:");
+    evenFinalResults.forEach(r => {
+      console.log(`  ${r.key}: ${r.found ? r.value : 'ОТСУТСТВУЕТ'}`);
+    });
+    
+    await checkR.commit();
+    
+    // 6. Тест межбазовых операций в одной транзакции
+    console.log("6. Тест межбазовых операций...");
+    const crossW = await env.startWrite();
+    const crossOddDbi = await crossW.openMap({ 
+      name: "odd_numbers", 
+      keyMode: keyMode.ordinal 
+    });
+    const crossEvenDbi = await crossW.openMap({ 
+      name: "even_numbers", 
+      keyMode: keyMode.ordinal 
+    });
+    
+    // Удаляем некоторые числа из обеих баз
+    console.log("Удаляем 5 из нечетных и 4 из четных...");
+    await crossOddDbi.delBatch([5n]);
+    await crossEvenDbi.delBatch([4n]);
+    
+    // Добавляем новые числа
+    console.log("Добавляем 11 в нечетные и 10 в четные...");
+    await crossOddDbi.putBatch([{ key: 11n, value: "одиннадцать" }]);
+    await crossEvenDbi.putBatch([{ key: 10n, value: "десять" }]);
+    
+    await crossW.commit();
+    
+    // 7. Финальная проверка
+    console.log("7. Финальная проверка всех баз...");
+    const finalCheckR = await env.startRead();
+    const finalOddDbi = await finalCheckR.openMap({ 
+      name: "odd_numbers", 
+      keyMode: keyMode.ordinal 
+    });
+    const finalEvenDbi = await finalCheckR.openMap({ 
+      name: "even_numbers", 
+      keyMode: keyMode.ordinal 
+    });
+    
+    const allOddKeys = [1n, 3n, 5n, 7n, 9n, 11n];
+    const allEvenKeys = [2n, 4n, 6n, 8n, 10n];
+    
+    const finalOddResults = await finalOddDbi.getBatch(allOddKeys);
+    const finalEvenResults = await finalEvenDbi.getBatch(allEvenKeys);
+    
+    console.log("Финальное состояние нечетных:");
+    finalOddResults.forEach(r => {
+      console.log(`  ${r.key}: ${r.found ? r.value : 'УДАЛЕНО'}`);
+    });
+    
+    console.log("Финальное состояние четных:");
+    finalEvenResults.forEach(r => {
+      console.log(`  ${r.key}: ${r.found ? r.value : 'УДАЛЕНО'}`);
+    });
+    
+    await finalCheckR.commit();
+    
+    await env.close();
+    console.log("Тест с двумя базами завершен успешно!");
+    
+  } catch (error) {
+    console.error("Ошибка теста:", error);
+  } finally {
+    try {
+      await env.terminate();
+    } catch (e) {
+      console.error("Ошибка при завершении:", e.message);
+    }
+  }
+})();

package/test/test-cursor-mode.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const fs = require('fs');
+const MDBX = require('../lib/nativemou.js');
+const { MDBX_Env, MDBX_Param } = MDBX;
+
+const testCursorMode = async () => {
+  const path = 'test-cursor-mode';
+
+  await Promise.all([
+    fs.promises.rm(path, { recursive: true, force: true })
+  ]);
+
+  const { keyMode, cursorMode } = MDBX_Param;
+
+  const db = new MDBX_Env();
+
+  console.log('Opening database...');
+  await db.open({
+      path: path,
+      valueFlag: MDBX_Param.valueFlag.string
+  });
+
+  // добавим тестовые данные
+  const w = db.startWrite();
+  const wdbi = w.createMap(keyMode.ordinal);
+  for (let i = 1; i <= 10; i++) {
+    wdbi.put(i, `value${i}`);
+  }
+  w.commit();
+
+  // читаем данные
+  const r = db.startRead();
+  const dbi = r.openMap(keyMode.ordinal);
+
+  console.log('=== Testing forEach variants ===');
+
+  // 1. forEach(fn)
+  console.log('\n1. forEach(fn):');
+  let count = dbi.forEach((k, v, i) => {
+    console.log(`  ${i}: ${k} = ${v}`);
+    return i >= 2; // останавливаем после 3 элементов
+  });
+  console.log(`Processed ${count} items`);
+
+  // 2. forEach(fromKey, fn)
+  console.log('\n2. forEach(fromKey=5, fn):');
+  count = dbi.forEach(5, (k, v, i) => {
+    console.log(`  ${i}: ${k} = ${v}`);
+    return i >= 2; // останавливаем после 3 элементов
+  });
+  console.log(`Processed ${count} items`);
+
+  // 3. forEach(fromKey, cursorMode, fn) - строковый режим
+  console.log('\n3. forEach(fromKey=7, "keyGreater", fn):');
+  count = dbi.forEach(7, 'keyGreater', (k, v, i) => {
+    console.log(`  ${i}: ${k} = ${v}`);
+    return i >= 1; // останавливаем после 2 элементов
+  });
+  console.log(`Processed ${count} items`);
+
+  // 4. forEach(fromKey, cursorMode, fn) - числовой режим key_lesser_or_equal (обратное сканирование)
+  console.log('\n4. forEach(fromKey=7, cursorMode.key_lesser_or_equal, fn):');
+  count = dbi.forEach(7, cursorMode.key_lesser_or_equal, (k, v, i) => {
+    console.log(`  ${i}: ${k} = ${v}`);
+    return i >= 2; // останавливаем после 3 элементов
+  });
+  console.log(`Processed ${count} items`);
+
+  // 5. forEach(fromKey, cursorMode, fn) - keyEqual
+  console.log('\n5. forEach(fromKey=5, "keyEqual", fn):');
+  count = dbi.forEach(5, 'keyEqual', (k, v, i) => {
+    console.log(`  ${i}: ${k} = ${v}`);
+    return i >= 0; // останавливаем после первого элемента для демонстрации
+  });
+  console.log(`Processed ${count} items`);
+
+  r.commit();
+  await db.close();
+  
+  console.log('\n=== Test completed successfully ===');
+}
+
+testCursorMode().catch(console.error);

package/test/test-multi-mode.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const fs = require('fs');
+const MDBX = require('../lib/nativemou.js');
+const { MDBX_Env, MDBX_Param } = MDBX;
+
+const testMultiMode = async () => {
+  const path = 'test-multi-mode';
+
+  await Promise.all([
+    fs.promises.rm(path, { recursive: true, force: true })
+  ]);
+
+  const { keyMode, valueMode, cursorMode } = MDBX_Param;
+
+  const db = new MDBX_Env();
+
+  console.log('Opening database with multi value mode...');
+  await db.open({
+      path: path,
+      valueFlag: MDBX_Param.valueFlag.string
+  });
+
+  // добавим тестовые данные в multi режиме
+  const w = db.startWrite();
+  const wdbi = w.createMap(keyMode.ordinal, valueMode.multi);
+  
+  // Добавляем несколько значений для одного ключа
+  wdbi.put(5, 'value5_1');
+  wdbi.put(5, 'value5_2');
+  wdbi.put(5, 'value5_3');
+  
+  // Добавляем данные для других ключей
+  for (let i = 1; i <= 10; i++) {
+    if (i !== 5) {
+      wdbi.put(i, `value${i}`);
+    }
+  }
+  
+  w.commit();
+
+  // читаем данные
+  const r = db.startRead();
+  const dbi = r.openMap(keyMode.ordinal, valueMode.multi);
+
+  console.log('=== Testing multi mode with key_equal ===');
+
+  // 1. Обычный forEach - должен показать все записи
+  console.log('\n1. forEach(fn) - все записи:');
+  let count = dbi.forEach((k, v, i) => {
+    console.log(`  ${i}: key=${k} value=${v}`);
+    return false; // продолжаем
+  });
+  console.log(`Total processed: ${count} items`);
+
+  // 2. forEach с key_equal для ключа 5 - должен показать все три записи
+  console.log('\n2. forEach(key=5, "keyEqual", fn) - три записи для ключа 5:');
+  count = dbi.forEach(5, 'keyEqual', (k, v, i) => {
+    console.log(`  ${i}: key=${k} value=${v}`);
+  });
+  console.log(`Processed: ${count} items`);
+
+  // 3. forEach с key_greater_or_equal для ключа 5 - должен показать все записи начиная с ключа 5
+  console.log('\n3. forEach(key=5, "keyGreaterOrEqual", fn) - все записи от ключа 5:');
+  count = dbi.forEach(5, 'keyGreaterOrEqual', (k, v, i) => {
+    console.log(`  ${i}: key=${k} value=${v}`);
+    return i >= 4; // останавливаем после 5 элементов
+  });
+  console.log(`Processed: ${count} items`);
+
+  // 4. keysFrom с key_equal - должен вернуть три ключа
+  console.log('\n4. keysFrom(key=5, limit=10, "keyEqual") - три ключа:');
+  const keysEqual = dbi.keysFrom(5, 10, 'keyEqual');
+  console.log(`Keys: [${keysEqual.join(', ')}]`);
+
+  // 5. keysFrom с key_greater_or_equal - должен вернуть все ключи от 5
+  console.log('\n5. keysFrom(key=5, limit=10, "keyGreaterOrEqual") - все ключи от 5:');
+  const keysGreater = dbi.keysFrom(5, 10, 'keyGreaterOrEqual');
+  console.log(`Keys: [${keysGreater.join(', ')}]`);
+
+  r.commit();
+  await db.close();
+  
+  console.log('\n=== Multi mode test completed successfully ===');
+}
+
+testMultiMode().catch(console.error);