NoSQL - Key Value Store

package nosql.bdb;

import java.io.Serializable;

public class Data implements Serializable {
    private static final long serialVersionUID = 1L;
    private int iv;
    private double xv;
    private String sv;
    public Data() {
        this(0, 0.0, "");
    }
    public Data(int iv, double xv, String sv) {
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

package nosql.bdb;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import com.sleepycat.db.Cursor;
import com.sleepycat.db.Database;
import com.sleepycat.db.DatabaseConfig;
import com.sleepycat.db.DatabaseEntry;
import com.sleepycat.db.DatabaseException;
import com.sleepycat.db.OperationStatus;

public class Test {
    private static DatabaseEntry prep(String key) throws UnsupportedEncodingException {
        return new DatabaseEntry(key.getBytes("UTF-8"));
    }
    private static DatabaseEntry serialize(Data o) throws IOException {
        ByteBuffer bb = ByteBuffer.allocate(1000);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.putInt(o.getIv());
        bb.putDouble(o.getXv());
        byte[] b = o.getSv().getBytes("UTF-8");
        bb.putShort((short)b.length);
        bb.put(b);
        int n = bb.position();
        byte[] res = new byte[n];
        bb.rewind();
        bb.get(res);
        return new DatabaseEntry(res);
    }
    private static Data deserialize(DatabaseEntry de) throws IOException, ClassNotFoundException {
        ByteBuffer bb = ByteBuffer.wrap(de.getData());
        bb.order(ByteOrder.LITTLE_ENDIAN);
        int iv = bb.getInt();
        double xv = bb.getDouble();
        int len = bb.getShort();
        byte[] temp = new byte[len];
        bb.get(temp);
        String sv = new String(temp, "UTF-8");
        Data res = new Data(iv, xv, sv);
        return res;
    }
    private static void dump(Database db, String key) throws ClassNotFoundException, IOException, DatabaseException {
        System.out.printf("Key=%s\n", key);
        DatabaseEntry rawvalue = new DatabaseEntry();
        if(db.get(null, prep(key), rawvalue, null) == OperationStatus.SUCCESS) {
            Data value = deserialize(rawvalue);
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final String DBNAME = "/work/bdb/test.db";
    private static final int NREC = 1000;
    private static final int JAVA_OFFSET = 2 * NREC;
    public static void main(String[] args) throws DatabaseException, UnsupportedEncodingException, IOException, ClassNotFoundException {
         Database db = new Database(DBNAME, null, new DatabaseConfig());
         // put data
         for(int i = 0; i < NREC; i++) {
             String key = "Key#" + (JAVA_OFFSET + i + 1);
             Data value = new Data();
             value.setIv(i + 1);
             value.setXv(i + 1.0);
             value.setSv(String.format("This is value %d", i + 1));
             db.put(null, prep(key), serialize(value));
         }
         //
         String key;
         key = "Key#" + (JAVA_OFFSET + 77);
         // get
         dump(db, key);
         // delete
         db.delete(null, prep(key));
         // get non existing
         dump(db, key);
         //
         key = "Key#" + (JAVA_OFFSET + 88);
         // update and get
         dump(db, key);
         DatabaseEntry rawvalue = new DatabaseEntry();
         db.get(null, prep(key), rawvalue, null);
         Data value = (Data)deserialize(rawvalue);
         value.setIv(value.getIv() + 1);
         value.setXv(value.getXv() + 0.1);
         value.setSv(value.getSv() + " updated");
         db.put(null, prep(key), serialize(value));
         dump(db, key);
         // list all
         Cursor it = db.openCursor(null, null);
         DatabaseEntry itrawkey = new DatabaseEntry();
         DatabaseEntry itrawvalue = new DatabaseEntry();
         OperationStatus itstat = it.getFirst(itrawkey, itrawvalue, null);
         int n = 0;
         while(itstat == OperationStatus.SUCCESS) {
             String itkey = new String(itrawkey.getData(), "UTF-8");
             if(!itkey.startsWith("Key#")) {
                 System.out.println("Unexpected key: " + itkey);
             }
             Data itvalue = (Data)deserialize(itrawvalue);
             if(itvalue.getIv() < 1 || NREC < itvalue.getIv()) {
                 System.out.println("Unexpected value :" + itvalue);
             }
             n++;
             itstat = it.getNext(itrawkey, itrawvalue, null);
         }
         it.close();
         System.out.println(n);
         // list keys where "Key#1075" <= key < "Key#1085"
         Cursor it2 = db.openCursor(null, null);
         DatabaseEntry it2rawkey = prep("Key#" + 1075);
         DatabaseEntry it2rawvalue = new DatabaseEntry();
         OperationStatus it2stat = it2.getSearchKey(it2rawkey, it2rawvalue, null);
         int n2 = 0;
         while(it2stat == OperationStatus.SUCCESS) {
             String it2key = new String(it2rawkey.getData(), "UTF-8");
             if(it2key.compareTo("Key#" + 1085) >= 0) break;
             n2++;
             it2stat = it2.getNext(it2rawkey, it2rawvalue, null);
         }
         it2.close();
         System.out.println(n2);
         //
         db.close();
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

using BerkeleyDB;

namespace BDB
{
    public class Data
    {
        public int Iv { get; set; }
        public double Xv { get; set; }
        public string Sv { get; set; }
        public override string ToString()
        {
            return string.Format("(iv: {0}, xv: {1}, sv: {2})", Iv, Xv, Sv);
        }
    }
    public class Program
    {
        private static DatabaseEntry Prep(string key)
        {
            return new DatabaseEntry(Encoding.UTF8.GetBytes(key));
        }
        private static DatabaseEntry Serialize(Data d)
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter bw = new BinaryWriter(ms);
            bw.Write(d.Iv);
            bw.Write(d.Xv);
            bw.Write((short)d.Sv.Length);
            bw.Write(Encoding.UTF8.GetBytes(d.Sv));
            bw.Flush();
            return new DatabaseEntry(ms.ToArray());
        }
        private static Data Deserialize(DatabaseEntry de)
        {
            MemoryStream ms = new MemoryStream(de.Data);
            BinaryReader br = new BinaryReader(ms);
            Data d = new Data();
            d.Iv = br.ReadInt32();
            d.Xv = br.ReadDouble();
            int len = br.ReadInt16();
            byte[] temp = new byte[len];
            br.Read(temp, 0, temp.Length);
            d.Sv = Encoding.UTF8.GetString(temp);
            return d;
        }
        private static void Dump(Database db, string key)
        {
            Console.WriteLine("Key={0}", key);
            if(db.Exists(Prep(key)))
            {
                Data value = Deserialize(db.Get(Prep(key)).Value);
                Console.WriteLine(value);
            }
            else 
            {
                Console.WriteLine("Not found");
            }
        }
        private const int NREC = 1000;
        private const int DN_OFFSET = 3 * NREC;
        public static void Main(string[] args)
        {
            using(Database db = BTreeDatabase.Open("/work/BDB/test.db", new BTreeDatabaseConfig()))
            {
                // put data
                for (int i = 0; i < NREC; i++)
                {
                    string putkey = "Key#" + (DN_OFFSET + i + 1);
                    Data value = new Data { Iv = i + 1, Xv = i + 1.0, Sv = string.Format("This is value {0}", i + 1) };
                    db.Put(Prep(putkey), Serialize(value));
                }
                string key;
                key = "Key#" + (DN_OFFSET + 77);
                // get
                Dump(db, key);
                // delete
                db.Delete(Prep(key));
                // get non existing
                Dump(db, key);
                //
                key = "Key#" + (DN_OFFSET + 88);
                // update and get
                Dump(db, key);
                Data updvalue = (Data)Deserialize(db.Get(Prep(key)).Value);
                updvalue.Iv = updvalue.Iv + 1;
                updvalue.Xv = updvalue.Xv + 0.1;
                updvalue.Sv = updvalue.Sv + " updated";
                db.Put(Prep(key), Serialize(updvalue));
                Dump(db, key);
                // list all
                using (Cursor it = db.Cursor())
                {
                    int n = 0;
                    bool more = it.MoveFirst();
                    while (more)
                    {
                        string itkey = Encoding.UTF8.GetString(it.Current.Key.Data);
                        if(!itkey.StartsWith("Key#"))
                        {
                            Console.WriteLine("Unexpected key: " + itkey);
                        }
                        Data itvalue = Deserialize(it.Current.Value);
                        if (itvalue.Iv < 1 || NREC < itvalue.Iv)
                        {
                            Console.WriteLine("Unexpected value :" + itvalue);
                        }
                        n++;
                        more = it.MoveNext();
                    }
                    Console.WriteLine(n);
                }
                // list all - alternative
                using (Cursor it1 = db.Cursor())
                {
                    int n1 = 0;
                    foreach(KeyValuePair<DatabaseEntry, DatabaseEntry> kvp in it1)
                    {
                        String it1key = Encoding.UTF8.GetString(kvp.Key.Data);
                        if(!it1key.StartsWith("Key#"))
                        {
                            Console.WriteLine("Unexpected key: " + it1key);
                        }
                        Data it1value = Deserialize(kvp.Value);
                        if (it1value.Iv < 1 || NREC < it1value.Iv)
                        {
                            Console.WriteLine("Unexpected value :" + it1value);
                        }
                        n1++;
                    }
                    Console.WriteLine(n1);
                }
                // list keys where "Key#n075" <= key < "Key#n085"
                using (Cursor it2 = db.Cursor())
                {
                    int n2 = 0;
                    bool more = it2.Move(Prep("Key#" + (DN_OFFSET + 75)), true);
                    while (more)
                    {
                        string it2key = Encoding.UTF8.GetString(it2.Current.Key.Data);
                        if(string.Compare(it2key, "Key#" + (DN_OFFSET + 85)) >= 0) break;
                        n2++;
                        more = it2.MoveNext();
                    }
                    Console.WriteLine(n2);
                }
            }
        }
    }
}

To use the C/C++ format the code will be using my Record library as that makes it a little bit easier.

package nosql.bdb;

import java.io.Serializable;

public class Data implements Serializable {
    private static final long serialVersionUID = 1L;
    private int iv;
    private double xv;
    private String sv;
    public Data() {
        this(0, 0.0, "");
    }
    public Data(int iv, double xv, String sv) {
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

package nosql.bdb;

import java.io.IOException;
import java.io.UnsupportedEncodingException;

import com.sleepycat.db.Cursor;
import com.sleepycat.db.Database;
import com.sleepycat.db.DatabaseConfig;
import com.sleepycat.db.DatabaseEntry;
import com.sleepycat.db.DatabaseException;
import com.sleepycat.db.OperationStatus;

import dk.vajhoej.record.Alignment;
import dk.vajhoej.record.Endian;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.RecordException;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;
import dk.vajhoej.record.StructReader;
import dk.vajhoej.record.StructWriter;

public class Test2 {
    @Struct(endianess=Endian.LITTLE, alignment=Alignment.ALIGN8, endpad=true)
    public static class CData {
        @StructField(n=0, type=FieldType.INT4)
        public int iv;
        @StructField(n=1, type=FieldType.FP8)
        public double xv;
        @StructField(n=2, type=FieldType.FIXSTRNULTERM, length=50)
        public String sv;
        //
        public CData() {
            iv = 0;
            xv = 0.0;
            sv = "";
        }
        public CData(Data d) {
            iv = d.getIv();
            xv = d.getXv();
            sv = d.getSv();
        }
        public Data getData() {
            return new Data(iv, xv, sv);
        }
    }
    private static DatabaseEntry prep(String key) throws UnsupportedEncodingException {
        return new DatabaseEntry(key.getBytes("UTF-8"));
    }
    private static DatabaseEntry serialize(Data o) throws IOException, RecordException {
        CData o2 = new CData(o);
        StructWriter sw = new StructWriter();
        sw.write(o2);
        return new DatabaseEntry(sw.getBytes());
    }
    private static Data deserialize(DatabaseEntry de) throws IOException, ClassNotFoundException, RecordException {
        StructReader sr = new StructReader(de.getData());
        CData o = sr.read(CData.class);
        return o.getData();
    }
    private static void dump(Database db, String key) throws ClassNotFoundException, IOException, DatabaseException, RecordException {
        System.out.printf("Key=%s\n", key);
        DatabaseEntry rawvalue = new DatabaseEntry();
        if(db.get(null, prep(key), rawvalue, null) == OperationStatus.SUCCESS) {
            Data value = deserialize(rawvalue);
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final String DBNAME = "/work/bdb/test2.db";
    private static final int NREC = 1000;
    private static final int JAVA_OFFSET = 2 * NREC;
    public static void main(String[] args) throws DatabaseException, UnsupportedEncodingException, IOException, ClassNotFoundException, RecordException {
         Database db = new Database(DBNAME, null, new DatabaseConfig());
         // put data
         for(int i = 0; i < NREC; i++) {
             String key = "Key#" + (JAVA_OFFSET + i + 1);
             Data value = new Data();
             value.setIv(i + 1);
             value.setXv(i + 1.0);
             value.setSv(String.format("This is value %d", i + 1));
             db.put(null, prep(key), serialize(value));
         }
         //
         String key;
         key = "Key#" + (JAVA_OFFSET + 77);
         // get
         dump(db, key);
         // delete
         db.delete(null, prep(key));
         // get non existing
         dump(db, key);
         //
         key = "Key#" + (JAVA_OFFSET + 88);
         // update and get
         dump(db, key);
         DatabaseEntry rawvalue = new DatabaseEntry();
         db.get(null, prep(key), rawvalue, null);
         Data value = (Data)deserialize(rawvalue);
         value.setIv(value.getIv() + 1);
         value.setXv(value.getXv() + 0.1);
         value.setSv(value.getSv() + " updated");
         db.put(null, prep(key), serialize(value));
         dump(db, key);
         // list all
         Cursor it = db.openCursor(null, null);
         DatabaseEntry itrawkey = new DatabaseEntry();
         DatabaseEntry itrawvalue = new DatabaseEntry();
         OperationStatus itstat = it.getFirst(itrawkey, itrawvalue, null);
         int n = 0;
         while(itstat == OperationStatus.SUCCESS) {
             String itkey = new String(itrawkey.getData(), "UTF-8");
             if(!itkey.startsWith("Key#")) {
                 System.out.println("Unexpected key: " + itkey);
             }
             Data itvalue = (Data)deserialize(itrawvalue);
             if(itvalue.getIv() < 1 || NREC < itvalue.getIv()) {
                 System.out.println("Unexpected value :" + itvalue);
             }
             n++;
             itstat = it.getNext(itrawkey, itrawvalue, null);
         }
         it.close();
         System.out.println(n);
         // list keys where "Key#1075" <= key < "Key#1085"
         Cursor it2 = db.openCursor(null, null);
         DatabaseEntry it2rawkey = prep("Key#" + 1075);
         DatabaseEntry it2rawvalue = new DatabaseEntry();
         OperationStatus it2stat = it2.getSearchKey(it2rawkey, it2rawvalue, null);
         int n2 = 0;
         while(it2stat == OperationStatus.SUCCESS) {
             String it2key = new String(it2rawkey.getData(), "UTF-8");
             if(it2key.compareTo("Key#" + 1085) >= 0) break;
             n2++;
             it2stat = it2.getNext(it2rawkey, it2rawvalue, null);
         }
         it2.close();
         System.out.println(n2);
         //
         db.close();
    }
}

To use the C/C++ format the code will be using my NRecord library as that makes it a little bit easier.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

using BerkeleyDB;

using Vajhoej.Record;

namespace BDB
{
    public class Data
    {
        public int Iv { get; set; }
        public double Xv { get; set; }
        public string Sv { get; set; }
        public override string ToString()
        {
            return string.Format("(iv: {0}, xv: {1}, sv: {2})", Iv, Xv, Sv);
        }
    }
    public class Program
    {
        [Struct(Endianess = Endian.LITTLE, Alignment = Alignment.ALIGN8, Endpad = true)]
        public class CData
        {
            [StructField(N = 0, Type = FieldType.INT4)]
            public int Iv;
            [StructField(N = 1, Type = FieldType.FP8)]
            public double Xv;
            [StructField(N = 2, Type = FieldType.FIXSTRNULTERM, Length = 50)]
            public String Sv;
            //
            public CData()
            {
                Iv = 0;
                Xv = 0.0;
                Sv = "";
            }
            public CData(Data o)
            {
                Iv = o.Iv;
                Xv = o.Xv;
                Sv = o.Sv;
            }
            public Data GetData()
            {
                return new Data { Iv = Iv, Xv = Xv, Sv = Sv };
            }
        }
        private static DatabaseEntry Prep(string key)
        {
            return new DatabaseEntry(Encoding.UTF8.GetBytes(key));
        }
        private static DatabaseEntry Serialize(Data d)
        {
            CData d2 = new CData(d);
            StructWriter sw = new StructWriter();
            sw.Write(d2);
            return new DatabaseEntry(sw.GetBytes());
        }
        private static Data Deserialize(DatabaseEntry de)
        {
            StructReader sr = new StructReader(de.Data);
            CData o = sr.Read<CData>(typeof(CData));
            return o.GetData();
        }
        private static void Dump(Database db, string key)
        {
            Console.WriteLine("Key={0}", key);
            if(db.Exists(Prep(key)))
            {
                Data value = Deserialize(db.Get(Prep(key)).Value);
                Console.WriteLine(value);
            }
            else 
            {
                Console.WriteLine("Not found");
            }
        }
        private const int NREC = 1000;
        private const int DN_OFFSET = 3 * NREC;
        public static void Main(string[] args)
        {
            using(Database db = BTreeDatabase.Open("/work/BDB/test2.db", new BTreeDatabaseConfig()))
            {
                // put data
                for (int i = 0; i < NREC; i++)
                {
                    string putkey = "Key#" + (DN_OFFSET + i + 1);
                    Data value = new Data { Iv = i + 1, Xv = i + 1.0, Sv = string.Format("This is value {0}", i + 1) };
                    db.Put(Prep(putkey), Serialize(value));
                }
                string key;
                key = "Key#" + (DN_OFFSET + 77);
                // get
                Dump(db, key);
                // delete
                db.Delete(Prep(key));
                // get non existing
                Dump(db, key);
                //
                key = "Key#" + (DN_OFFSET + 88);
                // update and get
                Dump(db, key);
                Data updvalue = (Data)Deserialize(db.Get(Prep(key)).Value);
                updvalue.Iv = updvalue.Iv + 1;
                updvalue.Xv = updvalue.Xv + 0.1;
                updvalue.Sv = updvalue.Sv + " updated";
                db.Put(Prep(key), Serialize(updvalue));
                Dump(db, key);
                // list all
                using (Cursor it = db.Cursor())
                {
                    int n = 0;
                    bool more = it.MoveFirst();
                    while (more)
                    {
                        string itkey = Encoding.UTF8.GetString(it.Current.Key.Data);
                        if(!itkey.StartsWith("Key#"))
                        {
                            Console.WriteLine("Unexpected key: " + itkey);
                        }
                        Data itvalue = Deserialize(it.Current.Value);
                        if (itvalue.Iv < 1 || NREC < itvalue.Iv)
                        {
                            Console.WriteLine("Unexpected value :" + itvalue);
                        }
                        n++;
                        more = it.MoveNext();
                    }
                    Console.WriteLine(n);
                }
                // list all - alternative
                using (Cursor it1 = db.Cursor())
                {
                    int n1 = 0;
                    foreach(KeyValuePair<DatabaseEntry, DatabaseEntry> kvp in it1)
                    {
                        String it1key = Encoding.UTF8.GetString(kvp.Key.Data);
                        if(!it1key.StartsWith("Key#"))
                        {
                            Console.WriteLine("Unexpected key: " + it1key);
                        }
                        Data it1value = Deserialize(kvp.Value);
                        if (it1value.Iv < 1 || NREC < it1value.Iv)
                        {
                            Console.WriteLine("Unexpected value :" + it1value);
                        }
                        n1++;
                    }
                    Console.WriteLine(n1);
                }
                // list keys where "Key#n075" <= key < "Key#n085"
                using (Cursor it2 = db.Cursor())
                {
                    int n2 = 0;
                    bool more = it2.Move(Prep("Key#" + (DN_OFFSET + 75)), true);
                    while (more)
                    {
                        string it2key = Encoding.UTF8.GetString(it2.Current.Key.Data);
                        if(string.Compare(it2key, "Key#" + (DN_OFFSET + 85)) >= 0) break;
                        n2++;
                        more = it2.MoveNext();
                    }
                    Console.WriteLine(n2);
                }
            }
        }
    }
}

There is an upcoming Java EE standard for NoSQL databases: Jakarta NoSQL. The reference implementation is Eclipse JNoSQL.

I have created a BDB-JE driver for it that can be downloaded here.

The example is tested with B2 release.

package nosql.bdbje.jnosql;

import java.io.Serializable;

public class Data implements Serializable {
    private static final long serialVersionUID = 1L;
    private int iv;
    private double xv;
    private String sv;
    public Data() {
        this(0, 0.0, "");
    }
    public Data(int iv, double xv, String sv) {
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

package nosql.bdbje.jnosql;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Optional;

import jakarta.nosql.Value;
import jakarta.nosql.keyvalue.BucketManager;
import jakarta.nosql.keyvalue.BucketManagerFactory;
import jakarta.nosql.keyvalue.KeyValueConfiguration;

import dk.vajhoej.jnosql.bdbje.BDBJEConfiguration;

public class Test {
    private static byte[] serialize(Data o) throws IOException {
        ByteBuffer bb = ByteBuffer.allocate(1000);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.putInt(o.getIv());
        bb.putDouble(o.getXv());
        byte[] b = o.getSv().getBytes("UTF-8");
        bb.putShort((short)b.length);
        bb.put(b);
        int n = bb.position();
        byte[] res = new byte[n];
        bb.rewind();
        bb.get(res);
        return res;
    }
    private static Data deserialize(byte[] b) throws IOException, ClassNotFoundException {
        ByteBuffer bb = ByteBuffer.wrap(b);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        int iv = bb.getInt();
        double xv = bb.getDouble();
        int len = bb.getShort();
        byte[] temp = new byte[len];
        bb.get(temp);
        String sv = new String(temp, "UTF-8");
        Data res = new Data(iv, xv, sv);
        return res;
    }
    private static void dump(BucketManager bm, String key) throws ClassNotFoundException, IOException {
        System.out.printf("Key=%s\n", key);
        Optional<Value> rawvalue = bm.get(key);
        if(rawvalue.isPresent()) {
            Data value = (Data)rawvalue.get().get();
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        KeyValueConfiguration cfg = new BDBJEConfiguration("/work/BDB", "testdb", false, o -> serialize((Data)o), b -> deserialize(b));
        BucketManagerFactory bmf = cfg.get();
        BucketManager bm = bmf.getBucketManager("testdb");
        // put data
        for(int i = 0; i < NREC; i++) {
            String key = "Key#" + (1000 + i + 1);
            Data value = new Data();
            value.setIv(i + 1);
            value.setXv(i + 1.0);
            value.setSv(String.format("This is value %d", i + 1));
            bm.put(key, value);
        }
        //
        String key;
        key = "Key#" + 1077;
        // get
        dump(bm, key);
        // delete
        bm.delete(key);
        // get non existing
        dump(bm, key);
        //
        key = "Key#" + 1088;
        // update and get
        dump(bm, key);
        Data value = (Data)bm.get(key).get().get();
        value.setIv(value.getIv() + 1);
        value.setXv(value.getXv() + 0.1);
        value.setSv(value.getSv() + " updated");
        bm.put(key, value);
        dump(bm, key);
        // list all
        // **** NOT SUPPORTED ****
        // list keys where "Key#1075" <= key < "Key#1085"
        // **** NOT SUPPORTED ****
        //
        bm.close();
        bmf.close();
    }
}

The configuration in:

        KeyValueConfiguration cfg = new BDBJEConfiguration("/work/BDB", "testdb", false, o -> serialize((Data)o), b -> deserialize(b));

can be externalized in bdbje.properties:

dbdir = /work/BDB
dbnam = testdb
prefix = false
to = nosql.bdbje.jnosql.Test$MySerializer
from = nosql.bdbje.jnosql.Test$MyDeserializer

and either:

        KeyValueConfiguration cfg = new BDBJEConfiguration();

or:

        KeyValueConfiguration cfg = KeyValueConfiguration.getConfiguration();

following nested classes are needed:

    public static class MySerializer implements Serialize {
        @Override
        public byte[] convert(Object obj) throws IOException {
            return serialize((Data)obj);
        }
    }
    public static class MyDeserializer implements Deserialize {
        @Override
        public Object convert(byte[] b) throws IOException, ClassNotFoundException {
            return deserialize(b);
        }
    }

package nosql.mapdb;

import java.io.IOException;
import java.util.Iterator;
import java.util.Map;

import org.mapdb.DB;
import org.mapdb.DBMaker;
import org.mapdb.BTreeMap;

public class Test2 {
    private static void dump(Map<String,Data> db, String key) throws ClassNotFoundException, IOException {
        System.out.printf("Key=%s\n", key);
        Data value = db.get(key);
        if(value != null) {
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        DB dbf = DBMaker.fileDB("/work/test2db.mdb").make();
        @SuppressWarnings("unchecked")
        Map<String,Data> db = (Map<String,Data>) dbf.treeMap("data").createOrOpen();
        // put data
        for(int i = 0; i < NREC; i++) {
            String key = "Key#" + (1000 + i + 1);
            Data value = new Data();
            value.setIv(i + 1);
            value.setXv(i + 1.0);
            value.setSv(String.format("This is value %d", i + 1));
            db.put(key, value);
        }
        //
        String key;
        key = "Key#" + 1077;
        // get
        dump(db, key);
        // delete
        db.remove(key);
        // get non existing
        dump(db, key);
        //
        key = "Key#" + 1088;
        // update and get
        dump(db, key);
        Data value = db.get(key);
        value.setIv(value.getIv() + 1);
        value.setXv(value.getXv() + 0.1);
        value.setSv(value.getSv() + " updated");
        db.put(key, value);
        dump(db, key);
        // list all
        Iterator<String> it = db.keySet().iterator();
        int n = 0;
        while(it.hasNext()) {
            String itkey = it.next();
            if(!itkey.startsWith("Key#")) {
                System.out.println("Unexpected key: " + itkey);
            }
            Data itvalue = db.get(itkey);
            if(itvalue.getIv() < 1 || NREC < itvalue.getIv()) {
                System.out.println("Unexpected value :" + itvalue);
            }
            n++;
        }
        System.out.println(n);
        // list keys where "Key#1075" <= key < "Key#1085"
        Iterator<String> it2 = ((BTreeMap<String,Data>)db).subMap("Key#1075", "Key#1085").keySet().iterator();
        int n2 = 0;
        while(it2.hasNext()) {
            String it2key = it2.next();
            @SuppressWarnings("unused")
            Data it2value = db.get(it2key);
            n2++;
        }
        System.out.println(n2);
        // close database
        dbf.close();
    }
}

package nosql.mapdb;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Iterator;
import java.util.Map;

import org.mapdb.DB;
import org.mapdb.DBMaker;
import org.mapdb.Serializer;
import org.mapdb.BTreeMap;

public class Test2X {
    private static byte[] prep(String key) throws UnsupportedEncodingException {
        return key.getBytes("UTF-8");
    }
    private static byte[] serialize(Data o) throws IOException {
        ByteBuffer bb = ByteBuffer.allocate(1000);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.putInt(o.getIv());
        bb.putDouble(o.getXv());
        byte[] b = o.getSv().getBytes("UTF-8");
        bb.putShort((short)b.length);
        bb.put(b);
        int n = bb.position();
        byte[] res = new byte[n];
        bb.rewind();
        bb.get(res);
        return res;
    }
    private static Data deserialize(byte[] b) throws IOException, ClassNotFoundException {
        ByteBuffer bb = ByteBuffer.wrap(b);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        int iv = bb.getInt();
        double xv = bb.getDouble();
        int len = bb.getShort();
        byte[] temp = new byte[len];
        bb.get(temp);
        String sv = new String(temp, "UTF-8");
        Data res = new Data(iv, xv, sv);
        return res;
    }
    private static void dump(Map<byte[],byte[]> db, String key) throws ClassNotFoundException, IOException {
        System.out.printf("Key=%s\n", key);
        byte[] rawvalue = db.get(prep(key));
        if(rawvalue != null) {
            Data value = deserialize(rawvalue);
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        DB dbf = DBMaker.fileDB("/work/test2xdb.mdb").make();
        Map<byte[],byte[]> db = dbf.treeMap("data", Serializer.BYTE_ARRAY, Serializer.BYTE_ARRAY).createOrOpen();
        // put data
        for(int i = 0; i < NREC; i++) {
            String key = "Key#" + (1000 + i + 1);
            Data value = new Data();
            value.setIv(i + 1);
            value.setXv(i + 1.0);
            value.setSv(String.format("This is value %d", i + 1));
            db.put(prep(key), serialize(value));
        }
        //
        String key;
        key = "Key#" + 1077;
        // get
        dump(db, key);
        // delete
        db.remove(prep(key));
        // get non existing
        dump(db, key);
        //
        key = "Key#" + 1088;
        // update and get
        dump(db, key);
        Data value = deserialize(db.get(prep(key)));
        value.setIv(value.getIv() + 1);
        value.setXv(value.getXv() + 0.1);
        value.setSv(value.getSv() + " updated");
        db.put(prep(key), serialize(value));
        dump(db, key);
        // list all
        Iterator<byte[]> it = db.keySet().iterator();
        int n = 0;
        while(it.hasNext()) {
            String itkey = new String(it.next());
            if(!itkey.startsWith("Key#")) {
                System.out.println("Unexpected key: " + itkey);
            }
            Data itvalue = deserialize(db.get(prep(itkey)));
            if(itvalue.getIv() < 1 || NREC < itvalue.getIv()) {
                System.out.println("Unexpected value :" + itvalue);
            }
            n++;
        }
        System.out.println(n);
        // list keys where "Key#1075" <= key < "Key#1085"
        Iterator<byte[]> it2 = ((BTreeMap<byte[],byte[]>)db).subMap(prep("Key#1075"), prep("Key#1085")).keySet().iterator();
        int n2 = 0;
        while(it2.hasNext()) {
            String it2key = new String(it2.next());
            byte[] it2rawvalue = db.get(prep(it2key));
            @SuppressWarnings("unused")
            Data it2value = deserialize(it2rawvalue);
            n2++;
        }
        System.out.println(n2);
        // close database
        dbf.close();
    }
}

package nosql.rocksdb;

import java.io.Serializable;

public class Data implements Serializable {
    private static final long serialVersionUID = 1L;
    private int iv;
    private double xv;
    private String sv;
    public Data() {
        this(0, 0.0, "");
    }
    public Data(int iv, double xv, String sv) {
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

package nosql.rocksdb;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import org.rocksdb.RocksDB;
import org.rocksdb.RocksDBException;
import org.rocksdb.RocksIterator;

public class Test {
    private static byte[] prep(String key) throws UnsupportedEncodingException {
        return key.getBytes("UTF-8");
    }
    private static byte[] serialize(Data o) throws IOException {
        ByteBuffer bb = ByteBuffer.allocate(1000);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.putInt(o.getIv());
        bb.putDouble(o.getXv());
        byte[] b = o.getSv().getBytes("UTF-8");
        bb.putShort((short)b.length);
        bb.put(b);
        int n = bb.position();
        byte[] res = new byte[n];
        bb.rewind();
        bb.get(res);
        return res;
    }
    private static Data deserialize(byte[] b) throws IOException, ClassNotFoundException {
        ByteBuffer bb = ByteBuffer.wrap(b);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        int iv = bb.getInt();
        double xv = bb.getDouble();
        int len = bb.getShort();
        byte[] temp = new byte[len];
        bb.get(temp);
        String sv = new String(temp, "UTF-8");
        Data res = new Data(iv, xv, sv);
        return res;
    }
    private static void dump(RocksDB db, String key) throws ClassNotFoundException, IOException, RocksDBException {
        System.out.printf("Key=%s\n", key);
        byte[] rawvalue = db.get(prep(key));
        if(rawvalue != null) {
            Data value = deserialize(rawvalue);
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    private static final int JAVA_OFFSET = 2 * NREC;
    public static void main(String[] args) throws RocksDBException, IOException, ClassNotFoundException {
        RocksDB.loadLibrary();
        try(RocksDB db = RocksDB.open("/work/R/DB")) {
            // put data
            for(int i = 0; i < NREC; i++) {
                String key = "Key#" + (JAVA_OFFSET + i + 1);
                Data value = new Data();
                value.setIv(i + 1);
                value.setXv(i + 1.0);
                value.setSv(String.format("This is value %d", i + 1));
                db.put(prep(key), serialize(value));
            }
            //
            String key;
            key = "Key#" + (JAVA_OFFSET + 77);
            // get
            dump(db, key);
            // delete
            db.delete(prep(key));
            // get non existing
            dump(db, key);
            //
            key = "Key#" + (JAVA_OFFSET + 88);
            // update and get
            dump(db, key);
            Data value = (Data)deserialize(db.get(prep(key)));
            value.setIv(value.getIv() + 1);
            value.setXv(value.getXv() + 0.1);
            value.setSv(value.getSv() + " updated");
            db.put(prep(key), serialize(value));
            dump(db, key);
            // list all
            try(RocksIterator it = db.newIterator()) {
                it.seekToFirst();
                int n = 0;
                while(it.isValid()) {
                    String itkey = new String(it.key(), "UTF-8");
                    if(!itkey.startsWith("Key#")) {
                        System.out.println("Unexpected key: " + itkey);
                    }
                    Data itvalue = (Data)deserialize(db.get(prep(itkey)));
                    if(itvalue.getIv() < 1 || NREC < itvalue.getIv()) {
                        System.out.println("Unexpected value :" + itvalue);
                    }
                    n++;
                    it.next();
                }
                System.out.println(n);
            }
            // list keys where "Key#n075" <= key < "Key#n085"
            try(RocksIterator it2 = db.newIterator()) {
                it2.seek(prep("Key#" + (JAVA_OFFSET + 75)));
                int n2 = 0;
                while(it2.isValid()) {
                    String it2key = new String(it2.key());
                    if(it2key.compareTo("Key#" + (JAVA_OFFSET + 85)) >= 0) break;
                    n2++;
                    it2.next();
                }
                System.out.println(n2);
            }
        }
    }
}

There is an upcoming Java EE standard for NoSQL databases: Jakarta NoSQL. The reference implementation is Eclipse JNoSQL.

I have created a RocksDB driver for it that can be downloaded here.

The example is tested with B2 release.

package nosql.rocksdb.jnosql;

import java.io.Serializable;

public class Data implements Serializable {
    private static final long serialVersionUID = 1L;
    private int iv;
    private double xv;
    private String sv;
    public Data() {
        this(0, 0.0, "");
    }
    public Data(int iv, double xv, String sv) {
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

package nosql.rocksdb.jnosql;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Optional;

import jakarta.nosql.Value;
import jakarta.nosql.keyvalue.BucketManager;
import jakarta.nosql.keyvalue.BucketManagerFactory;
import jakarta.nosql.keyvalue.KeyValueConfiguration;

import dk.vajhoej.jnosql.rocksdb.RocksDBConfiguration;

public class Test {
    private static byte[] serialize(Data o) throws IOException {
        ByteBuffer bb = ByteBuffer.allocate(1000);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.putInt(o.getIv());
        bb.putDouble(o.getXv());
        byte[] b = o.getSv().getBytes("UTF-8");
        bb.putShort((short)b.length);
        bb.put(b);
        int n = bb.position();
        byte[] res = new byte[n];
        bb.rewind();
        bb.get(res);
        return res;
    }
    private static Data deserialize(byte[] b) throws IOException, ClassNotFoundException {
        ByteBuffer bb = ByteBuffer.wrap(b);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        int iv = bb.getInt();
        double xv = bb.getDouble();
        int len = bb.getShort();
        byte[] temp = new byte[len];
        bb.get(temp);
        String sv = new String(temp, "UTF-8");
        Data res = new Data(iv, xv, sv);
        return res;
    }
    private static void dump(BucketManager bm, String key) throws ClassNotFoundException, IOException {
        System.out.printf("Key=%s\n", key);
        Optional<Value> rawvalue = bm.get(key);
        if(rawvalue.isPresent()) {
            Data value = (Data)rawvalue.get().get();
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        KeyValueConfiguration cfg = new RocksDBConfiguration("/work/R/DB", false, o -> serialize((Data)o), b -> deserialize(b));
        BucketManagerFactory bmf = cfg.get();
        BucketManager bm = bmf.getBucketManager("testdb");
        // put data
        for(int i = 0; i < NREC; i++) {
            String key = "Key#" + (1000 + i + 1);
            Data value = new Data();
            value.setIv(i + 1);
            value.setXv(i + 1.0);
            value.setSv(String.format("This is value %d", i + 1));
            bm.put(key, value);
        }
        //
        String key;
        key = "Key#" + 1077;
        // get
        dump(bm, key);
        // delete
        bm.delete(key);
        // get non existing
        dump(bm, key);
        //
        key = "Key#" + 1088;
        // update and get
        dump(bm, key);
        Data value = (Data)bm.get(key).get().get();
        value.setIv(value.getIv() + 1);
        value.setXv(value.getXv() + 0.1);
        value.setSv(value.getSv() + " updated");
        bm.put(key, value);
        dump(bm, key);
        // list all
        // **** NOT SUPPORTED ****
        // list keys where "Key#1075" <= key < "Key#1085"
        // **** NOT SUPPORTED ****
        //
        bm.close();
        bmf.close();
    }
}

The configuration in:

        KeyValueConfiguration cfg = new RocksDBConfiguration("/work/R/DB", false, o -> serialize((Data)o), b -> deserialize(b));

can be externalized in rocksdb.properties:

dbpath = /work/R/DB
prefix = false
to = nosql.rocksdb.jnosql.Test$MySerializer
from = nosql.rocksdb.jnosql.Test$MyDeserializer

and either:

KeyValueConfiguration cfg = new RocksDBConfiguration();

or:

        KeyValueConfiguration cfg = KeyValueConfiguration.getConfiguration();

following nested classes are needed:

    public static class MySerializer implements Serialize {
        @Override
        public byte[] convert(Object obj) throws IOException {
            return serialize((Data)obj);
        }
    }
    public static class MyDeserializer implements Deserialize {
        @Override
        public Object convert(byte[] b) throws IOException, ClassNotFoundException {
            return deserialize(b);
        }
    }

using System;
using System.IO;
using System.Text;

using RocksDbSharp;

namespace R
{
    public class Data
    {
        public int Iv { get; set; }
        public double Xv { get; set; }
        public string Sv { get; set; }
        public override string ToString()
        {
            return string.Format("(iv: {0}, xv: {1}, sv: {2})", Iv, Xv, Sv);
        }
    }
    public class Program
    {
        private static byte[] Prep(string key)
        {
            return Encoding.UTF8.GetBytes(key);
        }
        private static byte[] Serialize(Data d)
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter bw = new BinaryWriter(ms);
            bw.Write(d.Iv);
            bw.Write(d.Xv);
            bw.Write((short)d.Sv.Length);
            bw.Write(Encoding.UTF8.GetBytes(d.Sv));
            bw.Flush();
            return ms.ToArray();
        }
        private static Data Deserialize(byte[] b)
        {
            MemoryStream ms = new MemoryStream(b);
            BinaryReader br = new BinaryReader(ms);
            Data d = new Data();
            d.Iv = br.ReadInt32();
            d.Xv = br.ReadDouble();
            int len = br.ReadInt16();
            byte[] temp = new byte[len];
            br.Read(temp, 0, temp.Length);
            d.Sv = Encoding.UTF8.GetString(temp);
            return d;
        }
        private static void Dump(RocksDb db, string key)
        {
            Console.WriteLine("Key={0}", key);
            byte[] rawvalue = db.Get(Prep(key));
            if(rawvalue != null) {
                Data value = Deserialize(rawvalue);
                Console.WriteLine(value);
            }
            else 
            {
                Console.WriteLine("Not found");
            }
        }
        private const int NREC = 1000;
        private const int DN_OFFSET = 3 * NREC;
        public static void Main(string[] args)
        {
            using (RocksDb db = RocksDb.Open(new DbOptions().SetCreateIfMissing(true), "/work/R/DB"))
            {
                // put data
                for (int i = 0; i < NREC; i++)
                {
                    string putkey = "Key#" + (DN_OFFSET + i + 1);
                    Data value = new Data { Iv = i + 1, Xv = i + 1.0, Sv = string.Format("This is value {0}", i + 1) };
                    db.Put(Prep(putkey), Serialize(value));
                }
                //
                string key;
                key = "Key#" + (DN_OFFSET + 77);
                // get
                Dump(db, key);
                // delete
                db.Remove(Prep(key));
                // get non existing
                Dump(db, key);
                //
                key = "Key#" + (DN_OFFSET + 88);
                // update and get
                Dump(db, key);
                Data updvalue = (Data)Deserialize(db.Get(Prep(key)));
                updvalue.Iv = updvalue.Iv + 1;
                updvalue.Xv = updvalue.Xv + 0.1;
                updvalue.Sv = updvalue.Sv + " updated";
                db.Put(Prep(key), Serialize(updvalue));
                Dump(db, key);
                // list all
                using (Iterator it = db.NewIterator())
                {
                    it.SeekToFirst();
                    int n = 0;
                    while (it.Valid())
                    {
                        string itkey = Encoding.UTF8.GetString(it.Key());
                        if(!itkey.StartsWith("Key#"))
                        {
                            Console.WriteLine("Unexpected key: " + itkey);
                        }
                        Data itvalue = (Data)Deserialize(db.Get(Prep(itkey)));
                        if (itvalue.Iv < 1 || NREC < itvalue.Iv)
                        {
                            Console.WriteLine("Unexpected value :" + itvalue);
                        }
                        n++;
                        it.Next();
                    }
                    Console.WriteLine(n);
                }
                // list keys where "Key#75" <= key < "Key#85"
                using (Iterator it2 = db.NewIterator())
                {
                    it2.Seek(Prep("Key#" + (DN_OFFSET + 75)));
                    int n2 = 0;
                    while (it2.Valid())
                    {
                        string it2key = Encoding.UTF8.GetString(it2.Key());
                        if(string.Compare(it2key, "Key#" + (DN_OFFSET + 85)) >= 0) break;
                        n2++;
                        it2.Next();
                    }
                    Console.WriteLine(n2);
                }
            }
        }
    }
}

To use the C/C++ format the code will be using my Record library as that makes it a little bit easier.

package nosql.rocksdb;

import java.io.Serializable;

public class Data implements Serializable {
    private static final long serialVersionUID = 1L;
    private int iv;
    private double xv;
    private String sv;
    public Data() {
        this(0, 0.0, "");
    }
    public Data(int iv, double xv, String sv) {
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

package nosql.rocksdb;

import java.io.IOException;
import java.io.UnsupportedEncodingException;

import org.rocksdb.RocksDB;
import org.rocksdb.RocksDBException;
import org.rocksdb.RocksIterator;

import dk.vajhoej.record.Alignment;
import dk.vajhoej.record.Endian;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.RecordException;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;
import dk.vajhoej.record.StructReader;
import dk.vajhoej.record.StructWriter;

public class TestAlt {
    @Struct(endianess=Endian.LITTLE, alignment=Alignment.ALIGN8)
    public static class CData {
        @StructField(n=0, type=FieldType.INT4)
        public int iv;
        @StructField(n=1, type=FieldType.FP8)
        public double xv;
        @StructField(n=2, type=FieldType.FIXSTRNULTERM, length=50)
        public String sv;
        //
        public CData() {
            iv = 0;
            xv = 0.0;
            sv = "";
        }
        public CData(Data d) {
            iv = d.getIv();
            xv = d.getXv();
            sv = d.getSv();
        }
        public Data getData() {
            return new Data(iv, xv, sv);
        }
    }
    private static byte[] prep(String key) throws UnsupportedEncodingException {
        return key.getBytes("UTF-8");
    }
    private static byte[] serialize(Data o) throws IOException, RecordException {
        CData o2 = new CData(o);
        StructWriter sw = new StructWriter();
        sw.write(o2);
        return sw.getBytes();
    }
    private static Data deserialize(byte[] b) throws IOException, ClassNotFoundException, RecordException {
        StructReader sr = new StructReader(b);
        CData o = sr.read(CData.class);
        return o.getData();
    }
    private static void dump(RocksDB db, String key) throws ClassNotFoundException, IOException, RocksDBException, RecordException {
        System.out.printf("Key=%s\n", key);
        byte[] rawvalue = db.get(prep(key));
        if(rawvalue != null) {
            Data value = deserialize(rawvalue);
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    private static final int JAVA_OFFSET = 2 * NREC;
    public static void main(String[] args) throws RocksDBException, IOException, ClassNotFoundException, RecordException {
        RocksDB.loadLibrary();
        try(RocksDB db = RocksDB.open("/work/R/DB")) {
            // put data
            for(int i = 0; i < NREC; i++) {
                String key = "Key#" + (JAVA_OFFSET + i + 1);
                Data value = new Data();
                value.setIv(i + 1);
                value.setXv(i + 1.0);
                value.setSv(String.format("This is value %d", i + 1));
                db.put(prep(key), serialize(value));
            }
            //
            String key;
            key = "Key#" + (JAVA_OFFSET + 77);
            // get
            dump(db, key);
            // delete
            db.delete(prep(key));
            // get non existing
            dump(db, key);
            //
            key = "Key#" + (JAVA_OFFSET + 88);
            // update and get
            dump(db, key);
            Data value = (Data)deserialize(db.get(prep(key)));
            value.setIv(value.getIv() + 1);
            value.setXv(value.getXv() + 0.1);
            value.setSv(value.getSv() + " updated");
            db.put(prep(key), serialize(value));
            dump(db, key);
            // list all
            try(RocksIterator it = db.newIterator()) {
                it.seekToFirst();
                int n = 0;
                while(it.isValid()) {
                    String itkey = new String(it.key(), "UTF-8");
                    if(!itkey.startsWith("Key#")) {
                        System.out.println("Unexpected key: " + itkey);
                    }
                    Data itvalue = (Data)deserialize(db.get(prep(itkey)));
                    if(itvalue.getIv() < 1 || NREC < itvalue.getIv()) {
                        System.out.println("Unexpected value :" + itvalue);
                    }
                    n++;
                    it.next();
                }
                System.out.println(n);
            }
            // list keys where "Key#n075" <= key < "Key#n085"
            try(RocksIterator it2 = db.newIterator()) {
                it2.seek(prep("Key#" + (JAVA_OFFSET + 75)));
                int n2 = 0;
                while(it2.isValid()) {
                    String it2key = new String(it2.key());
                    if(it2key.compareTo("Key#" + (JAVA_OFFSET + 85)) >= 0) break;
                    n2++;
                    it2.next();
                }
                System.out.println(n2);
            }
        }
    }
}

There is an upcoming Java EE standard for NoSQL databases: Jakarta NoSQL. The reference implementation is Eclipse JNoSQL.

I have created a RocksDB driver for it that can be downloaded here.

The example is tested with B2 release.

To use the C/C++ format the code will be using my Record library as that makes it a little bit easier.

package nosql.rocksdb.jnosql;

import java.io.Serializable;

public class Data implements Serializable {
    private static final long serialVersionUID = 1L;
    private int iv;
    private double xv;
    private String sv;
    public Data() {
        this(0, 0.0, "");
    }
    public Data(int iv, double xv, String sv) {
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

package nosql.rocksdb.jnosql;

import java.io.IOException;
import java.util.Optional;

import jakarta.nosql.Value;
import jakarta.nosql.keyvalue.BucketManager;
import jakarta.nosql.keyvalue.BucketManagerFactory;
import jakarta.nosql.keyvalue.KeyValueConfiguration;

import dk.vajhoej.jnosql.rocksdb.RocksDBConfiguration;
import dk.vajhoej.record.Alignment;
import dk.vajhoej.record.Endian;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.RecordException;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;
import dk.vajhoej.record.StructReader;
import dk.vajhoej.record.StructWriter;

public class Test2 {
    @Struct(endianess=Endian.LITTLE, alignment=Alignment.ALIGN8)
    public static class CData {
        @StructField(n=0, type=FieldType.INT4)
        public int iv;
        @StructField(n=1, type=FieldType.FP8)
        public double xv;
        @StructField(n=2, type=FieldType.FIXSTRNULTERM, length=50)
        public String sv;
        //
        public CData() {
            iv = 0;
            xv = 0.0;
            sv = "";
        }
        public CData(Data d) {
            iv = d.getIv();
            xv = d.getXv();
            sv = d.getSv();
        }
        public Data getData() {
            return new Data(iv, xv, sv);
        }
    }
    private static byte[] serialize(Data o) throws IOException {
        try {
            CData o2 = new CData(o);
            StructWriter sw = new StructWriter();
            sw.write(o2);
            return sw.getBytes();
        } catch (RecordException e) {
            throw new IOException(e);
        }
    }
    private static Data deserialize(byte[] b) throws IOException, ClassNotFoundException {
        try {
            StructReader sr = new StructReader(b);
            CData o = sr.read(CData.class);
            return o.getData();
        } catch (RecordException e) {
            throw new IOException(e);
        }
    }
    private static void dump(BucketManager bm, String key) throws ClassNotFoundException, IOException {
        System.out.printf("Key=%s\n", key);
        Optional<Value> rawvalue = bm.get(key);
        if(rawvalue.isPresent()) {
            Data value = (Data)rawvalue.get().get();
            System.out.println(value);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        KeyValueConfiguration cfg = new RocksDBConfiguration("/work/R/DB", false, o -> serialize((Data)o), b -> deserialize(b));
        BucketManagerFactory bmf = cfg.get();
        BucketManager bm = bmf.getBucketManager("testdb");
        // put data
        for(int i = 0; i < NREC; i++) {
            String key = "Key#" + (1000 + i + 1);
            Data value = new Data();
            value.setIv(i + 1);
            value.setXv(i + 1.0);
            value.setSv(String.format("This is value %d", i + 1));
            bm.put(key, value);
        }
        //
        String key;
        key = "Key#" + 1077;
        // get
        dump(bm, key);
        // delete
        bm.delete(key);
        // get non existing
        dump(bm, key);
        //
        key = "Key#" + 1088;
        // update and get
        dump(bm, key);
        Data value = (Data)bm.get(key).get().get();
        value.setIv(value.getIv() + 1);
        value.setXv(value.getXv() + 0.1);
        value.setSv(value.getSv() + " updated");
        bm.put(key, value);
        dump(bm, key);
        // list all
        // **** NOT SUPPORTED ****
        // list keys where "Key#1075" <= key < "Key#1085"
        // **** NOT SUPPORTED ****
        //
        bm.close();
        bmf.close();
    }
}

To use the C/C++ format the code will be using my NRecord library as that makes it a little bit easier.

using System;
using System.IO;
using System.Text;

using RocksDbSharp;

using Vajhoej.Record;

namespace R
{
    public class Data
    {
        public int Iv { get; set; }
        public double Xv { get; set; }
        public string Sv { get; set; }
        public override string ToString()
        {
            return string.Format("(iv: {0}, xv: {1}, sv: {2})", Iv, Xv, Sv);
        }
    }
    public class Program
    {
        [Struct(Endianess = Endian.LITTLE, Alignment = Alignment.ALIGN8)]
        public class CData
        {
            [StructField(N = 0, Type = FieldType.INT4)]
            public int Iv;
            [StructField(N = 1, Type = FieldType.FP8)]
            public double Xv;
            [StructField(N = 2, Type = FieldType.FIXSTRNULTERM, Length = 50)]
            public String Sv;
            //
            public CData()
            {
                Iv = 0;
                Xv = 0.0;
                Sv = "";
            }
            public CData(Data o)
            {
                Iv = o.Iv;
                Xv = o.Xv;
                Sv = o.Sv;
            }
            public Data GetData()
            {
                return new Data { Iv = Iv, Xv = Xv, Sv = Sv };
            }
        }
        private static byte[] Prep(string key)
        {
            return Encoding.UTF8.GetBytes(key);
        }
        private static byte[] Serialize(Data d)
        {
            CData d2 = new CData(d);
            StructWriter sw = new StructWriter();
            sw.Write(d2);
            return sw.GetBytes();
        }
        private static Data Deserialize(byte[] b)
        {
            StructReader sr = new StructReader(b);
            CData o = sr.Read<CData>(typeof(CData));
            return o.GetData();
        }
        private static void Dump(RocksDb db, string key)
        {
            Console.WriteLine("Key={0}", key);
            byte[] rawvalue = db.Get(Prep(key));
            if (rawvalue != null)
            {
                Data value = Deserialize(rawvalue);
                Console.WriteLine(value);
            }
            else
            {
                Console.WriteLine("Not found");
            }
        }
        private const int NREC = 1000;
        private const int DN_OFFSET = 3 * NREC;
        public static void Main(string[] args)
        {
            using (RocksDb db = RocksDb.Open(new DbOptions().SetCreateIfMissing(true), "/work/R/DB"))
            {
                // put data
                for (int i = 0; i < NREC; i++)
                {
                    string putkey = "Key#" + (DN_OFFSET + i + 1);
                    Data value = new Data { Iv = i + 1, Xv = i + 1.0, Sv = string.Format("This is value {0}", i + 1) };
                    db.Put(Prep(putkey), Serialize(value));
                }
                //
                string key;
                key = "Key#" + (DN_OFFSET + 77);
                // get
                Dump(db, key);
                // delete
                db.Remove(Prep(key));
                // get non existing
                Dump(db, key);
                //
                key = "Key#" + (DN_OFFSET + 88);
                // update and get
                Dump(db, key);
                Data updvalue = (Data)Deserialize(db.Get(Prep(key)));
                updvalue.Iv = updvalue.Iv + 1;
                updvalue.Xv = updvalue.Xv + 0.1;
                updvalue.Sv = updvalue.Sv + " updated";
                db.Put(Prep(key), Serialize(updvalue));
                Dump(db, key);
                // list all
                using (Iterator it = db.NewIterator())
                {
                    it.SeekToFirst();
                    int n = 0;
                    while (it.Valid())
                    {
                        string itkey = Encoding.UTF8.GetString(it.Key());
                        if (!itkey.StartsWith("Key#"))
                        {
                            Console.WriteLine("Unexpected key: " + itkey);
                        }
                        Data itvalue = (Data)Deserialize(db.Get(Prep(itkey)));
                        if (itvalue.Iv < 1 || NREC < itvalue.Iv)
                        {
                            Console.WriteLine("Unexpected value :" + itvalue);
                        }
                        n++;
                        it.Next();
                    }
                    Console.WriteLine(n);
                }
                // list keys where "Key#75" <= key < "Key#85"
                using (Iterator it2 = db.NewIterator())
                {
                    it2.Seek(Prep("Key#" + (DN_OFFSET + 75)));
                    int n2 = 0;
                    while (it2.Valid())
                    {
                        string it2key = Encoding.UTF8.GetString(it2.Key());
                        if (string.Compare(it2key, "Key#" + (DN_OFFSET + 85)) >= 0) break;
                        n2++;
                        it2.Next();
                    }
                    Console.WriteLine(n2);
                }
            }
        }
    }
}

program test

record datarec
    string id = 8
    long iv
    gfloat xv
    word slen
    string sv = 50
end record
declare integer constant NREC = 1000
declare integer constant BASIC_OFFSET = 6 * NREC
declare integer i, n, n2
declare string id0, idstart, idstop
map (databuf) datarec d

open "testdb.isq" as file #1, indexed fixed, recordtype none, map databuf, primary key d::id
! put
for i = 1 to NREC
    d::id = format$(BASIC_OFFSET + i, "Key_#####")
    d::iv = i
    d::xv = i
    d::slen = 18
    d::sv = format$(i, "This is value ####")
    put #1
next i
!
id0 = format$(BASIC_OFFSET + 77, "Key_#####")
! get
gosub dump
! delete
find #1, key #0 eq id0
delete #1
! get non existing
gosub dump
!
id0 = format$(BASIC_OFFSET + 88, "Key_#####")
! update and get
gosub dump
get #1, key #0 eq id0
d::iv = d::iv + 1
d::xv = d::xv + 0.1
d::slen = d::slen + 8
mid(d::sv,19,8) = " updated"
update #1
gosub dump
! list all
n = 0
reset #1
handler eof_handler
end handler
when error use eof_handler
    while 1 = 1
        get #1
        if mid(d::id,1, 4) <> "Key#" then
            print using "Unexpected key: 'E", d::id
        end if
        if d::iv < 1 or NREC < d::iv then
            print using "Unexpected value: (#### ####.## 'E)",d::iv,d::xv,mid(d::sv,1,d::slen)
        end if
        n = n + 1
    next
end when
print n
! list keys where "Key#n075" <= key < "Key#n085"
idstart = format$(BASIC_OFFSET + 75, "Key_#####")
idstop = format$(BASIC_OFFSET + 85, "Key_#####")
find #1, key #0 ge idstart
n2 = 0
when error use eof_handler
loop:
    while 1 = 1
        get #1
        if d::id >= idstop then
            exit loop
        end if
        n2 = n2 + 1
    next
end when
print n2
!
close #1
exit program

dump:
print id0
handler notf_handler
    print "Not found"
end handler
when error use notf_handler
    get #1, key #0 eq id0
    print using "(####_,####.##_,'E)",d::iv,d::xv,mid(d::sv,1,d::slen)
end when
return

end program

On VMS the Cobol standard indexed file is mapped to RMS index-sequential files.

IDENTIFICATION DIVISION.
PROGRAM-ID. TEST-PROGRAM.

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT OPTIONAL D-FILE ASSIGN TO "TESTDB.ISQ" ORGANIZATION IS INDEXED ACCESS MODE IS DYNAMIC RECORD KEY IS D-ID.

DATA DIVISION.
FILE SECTION.
FD D-FILE.
01 D-RECORD.
    03 D-ID PIC X(8).
    03 D-IV PIC 9(8) COMP.
    03 D-XV COMP-2.
    03 D-SLEN PIC 9(4) COMP.
    03 D-SV PIC X(50).
WORKING-STORAGE SECTION.
01 NREC PIC 9(4) COMP VALUE 1000.
01 COB_OFFSET PIC 9(4) COMP VALUE 2000.
01 BLANK-VAL PIC X(8) VALUE "        ".
01 EOF-FLAG PIC X.
01 DONE-FLAG PIC X.
01 WID PIC 9(4) DISPLAY.
01 IV PIC 9(4) DISPLAY.
01 XV PIC 9(4)V9(2) DISPLAY.
01 SLEN PIC 9(2) DISPLAY.
01 SV PIC X(50).
01 I PIC 9(4) DISPLAY.
01 N PIC 9(4) DISPLAY.
01 N2 PIC 9(4) DISPLAY.
01 STOP-ID PIC X(8).

PROCEDURE DIVISION.
MAIN-PARAGRAPH.
    OPEN I-O D-FILE
    MOVE BLANK-VAL TO D-ID
    START D-FILE KEY GREATER THAN D-ID
        INVALID KEY DISPLAY "Empty file"
    END-START
    PERFORM VARYING I FROM 1 BY 1 UNTIL I > NREC
        COMPUTE WID = COB_OFFSET + I
        STRING "Key#" DELIMITED BY SIZE WID DELIMITED BY SIZE INTO D-ID
        COMPUTE D-IV = I
        COMPUTE D-XV = I
        COMPUTE D-SLEN = 18
        STRING "This is value " DELIMITED BY SIZE I DELIMITED BY SIZE INTO D-SV
        WRITE D-RECORD
            INVALID KEY DISPLAY "Error writing"
            NOT INVALID KEY CONTINUE
        END-WRITE
    END-PERFORM
    COMPUTE WID = COB_OFFSET + 77
    STRING "Key#" DELIMITED BY SIZE WID DELIMITED BY SIZE INTO D-ID
    PERFORM DUMP-PARAGRAPH
    DELETE D-FILE
        INVALID KEY DISPLAY "Error deleting"
        NOT INVALID KEY CONTINUE
    END-DELETE
    PERFORM DUMP-PARAGRAPH
    COMPUTE WID = COB_OFFSET + 88
    STRING "Key#" DELIMITED BY SIZE WID DELIMITED BY SIZE INTO D-ID
    PERFORM DUMP-PARAGRAPH
    READ D-FILE
        INVALID KEY DISPLAY "Error reading"
        NOT INVALID KEY CONTINUE
    END-READ
    COMPUTE D-IV = D-IV + 1
    COMPUTE D-XV = D-XV + 0.1
    MOVE D-SLEN TO SLEN
    MOVE D-SV TO SV
    STRING SV(1:SLEN) DELIMITED BY SIZE " updated" DELIMITED BY SIZE INTO D-SV
    COMPUTE D-SLEN = D-SLEN + 8
    REWRITE D-RECORD
        INVALID KEY DISPLAY "Error updating"
        NOT INVALID KEY CONTINUE
    END-REWRITE
    PERFORM DUMP-PARAGRAPH
    MOVE BLANK-VAL TO D-ID
    START D-FILE KEY IS GREATER THAN D-ID
        INVALID KEY DISPLAY "Error rewinding"
        NOT INVALID KEY CONTINUE
    END-START
    MOVE 'N' TO EOF-FLAG
    MOVE 0 TO N
    PERFORM UNTIL EOF-FLAG = 'Y'
        READ D-FILE NEXT
            AT END MOVE 'Y' TO EOF-FLAG
            NOT AT END PERFORM CHECK-AND-COUNT-PARAGRAPH
        END-READ
    END-PERFORM
    DISPLAY N
    COMPUTE WID = COB_OFFSET + 75
    STRING "Key#" DELIMITED BY SIZE WID DELIMITED BY SIZE INTO D-ID
    START D-FILE KEY IS GREATER THAN OR EQUAL TO D-ID
        INVALID KEY DISPLAY "Error searching"
        NOT INVALID KEY CONTINUE
    END-START
    COMPUTE WID = COB_OFFSET + 85
    STRING "Key#" DELIMITED BY SIZE WID DELIMITED BY SIZE INTO STOP-ID
    MOVE 'N' TO EOF-FLAG
    MOVE 'N' TO DONE-FLAG
    MOVE 0 TO N2
    PERFORM UNTIL EOF-FLAG = 'Y' OR DONE-FLAG = 'Y'
        READ D-FILE NEXT
            AT END MOVE 'Y' TO EOF-FLAG
            NOT AT END PERFORM COUNT-PARAGRAPH
        END-READ
    END-PERFORM
    DISPLAY N2
    CLOSE D-FILE
    STOP RUN.
DUMP-PARAGRAPH.
    DISPLAY "Key=" D-ID
    READ D-FILE
        INVALID KEY DISPLAY "Not found"
        NOT INVALID KEY PERFORM DUMP-DATA-PARAGRAPH
    END-READ.
DUMP-DATA-PARAGRAPH.
    MOVE D-IV TO IV
    MOVE D-XV TO XV
    MOVE D-SLEN TO SLEN
    MOVE D-SV TO SV
    DISPLAY  "(" IV "," XV "," SV(1:SLEN) ")".
CHECK-AND-COUNT-PARAGRAPH.
    MOVE D-IV TO IV
    MOVE D-XV TO XV
    MOVE D-SLEN TO SLEN
    MOVE D-SV TO SV
    IF IV < 1 OR NREC < IV THEN
        DISPLAY  "Unexpected value: (" IV "," XV "," SV(1:SLEN) ")"
    END-IF
    COMPUTE N = N + 1.
COUNT-PARAGRAPH.
    IF D-ID GREATER THAN OR EQUAL TO STOP-ID THEN
        MOVE 'Y' TO DONE-FLAG
    ELSE
        COMPUTE N2 = N2 + 1
    END-IF.

/* standard C headers */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/* RMS headers */
#include <starlet.h>
#include <rms.h>

/* data structure */
#pragma member_alignment save
#pragma nomember_alignment
#define KEYSIZ 8
struct data
{
    char id[KEYSIZ];
    int iv;
    double xv;
    short slen;
    char sv[50];
};
#define RECSIZ sizeof(struct data)
#pragma member_alignment restore

/* error handling functions */
void rms_exit(long stat)
{
    printf("Error code: %d\n", stat);
    exit(1);
}

static void dump(struct RAB *rab, char *id)
{
    long stat;
    struct data d;
    printf("Key=%s\n", id);
    rab->rab$l_kbf = id;
    rab->rab$b_ksz = KEYSIZ;
    rab->rab$b_krf = 0;
    rab->rab$l_rop = 0;
    rab->rab$l_ubf = &d.id[0];
    rab->rab$w_usz = RECSIZ;
    stat = sys$get(rab, 0, 0);
    if((stat & 1) && (memcmp(d.id, id, KEYSIZ) == 0)) {
        printf("(%d,%f,%s)\n", d.iv, d.xv, d.sv);
    } else {
        printf("Not found\n");
    }
}

static const char *FNM = "testdb.isq";
static const int NREC = 1000;
static const int C_OFFSET = 3 * NREC;

int main()
{
    long stat;
    struct FAB fab;
    struct RAB rab;
    struct XABKEY xab;
    char id[KEYSIZ + 1], startid[KEYSIZ + 1], stopid[KEYSIZ + 1];
    struct data d;
    int n, n2;
    /* open */
    fab = cc$rms_fab;
    fab.fab$l_fna = (char *)FNM;
    fab.fab$b_fns = strlen(FNM);
    fab.fab$b_org = FAB$C_IDX;
    fab.fab$b_rfm = FAB$C_FIX;
    fab.fab$b_rat = FAB$M_CR;
    fab.fab$l_fop = FAB$M_CIF;
    fab.fab$w_mrs = RECSIZ;
    fab.fab$b_fac = FAB$M_GET | FAB$M_PUT | FAB$M_UPD | FAB$M_DEL;
    fab.fab$l_xab = (char *)&xab;
    xab = cc$rms_xabkey;
    xab.xab$b_dtp = XAB$C_STG;
    xab.xab$w_pos0 = 0;
    xab.xab$b_ref = 0;
    xab.xab$b_siz0 = KEYSIZ;
    stat = sys$create(&fab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    fab.fab$l_xab = 0;
    rab = cc$rms_rab;
    rab.rab$l_fab = &fab;
    rab.rab$b_rac = RAB$C_KEY;
    stat = sys$connect(&rab, 0 ,0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    /* put data */
    for(int i = 0; i < NREC; i++)
    {
        sprintf(id, "Key#%d", C_OFFSET + i + 1);
        memcpy(d.id, id, KEYSIZ);
        d.iv = i + 1;
        d.xv = i + 1.0;
        sprintf(d.sv, "This is value %d", i + 1);
        d.slen = strlen(d.sv);
        rab.rab$l_rbf = &d.id[0];
        rab.rab$w_rsz = RECSIZ;
        stat = sys$put(&rab, 0, 0);
        if(!(stat & 1)) {
            rms_exit(stat);
        }
    }
    /* */
    sprintf(id, "Key#%d", C_OFFSET + 77);
    /* get */
    dump(&rab, id);
    /* delete */
    rab.rab$l_kbf = id;
    rab.rab$b_ksz = KEYSIZ;
    rab.rab$b_krf = 0;
    rab.rab$l_rop = RAB$M_KGE;
    stat = sys$find(&rab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    stat = sys$delete(&rab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    /* get non existing */
    dump(&rab, id);
    /* */
    sprintf(id, "Key#%d", C_OFFSET + 88);
    /* update and get */
    dump(&rab, id);
    rab.rab$l_kbf = id;
    rab.rab$b_ksz = KEYSIZ;
    rab.rab$b_krf = 0;
    rab.rab$l_rop = 0;
    rab.rab$l_ubf = &d.id[0];
    rab.rab$w_usz = RECSIZ;
    stat = sys$get(&rab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    d.iv = d.iv + 1;
    d.xv = d.xv + 0.1;
    strcat(d.sv, " updated");
    d.slen = strlen(d.sv);
    rab.rab$l_rbf = &d.id[0];
    rab.rab$w_rsz = RECSIZ;
    stat = sys$update(&rab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    dump(&rab, id);
    /* list all */
    n = 0;
    stat = sys$rewind(&rab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    rab.rab$b_rac = RAB$C_SEQ; /* switch to sequential access mode */
    for(;;)
    {
        rab.rab$l_kbf = 0;
        rab.rab$b_ksz = 0;
        rab.rab$b_krf = 0;
        rab.rab$l_rop = 0;
        rab.rab$l_ubf = &d.id[0];
        rab.rab$w_usz = RECSIZ;
        stat = sys$get(&rab, 0, 0);
        if(!(stat & 1)) break;
        if(strstr(d.id, "Key#") != d.id) 
        {
            printf("Unexpected key: %s\n", d.id);
        }
        if (d.iv < 1 || NREC < d.iv)
        {
            printf("Unexpected value: (%d,%f,%s)\n", d.iv, d.xv, d.sv);
        }
        n++;
    }
    rab.rab$b_rac = RAB$C_KEY; /* switch back to keyed access mode */
    printf("%d\n", n);
    /* list keys where "Key#n075" <= key < "Key#n085" */
    sprintf(startid, "Key#%d", C_OFFSET + 75);
    sprintf(stopid, "Key#%d", C_OFFSET + 85);
    rab.rab$l_kbf = startid;
    rab.rab$b_ksz = KEYSIZ;
    rab.rab$b_krf = 0;
    rab.rab$l_rop = RAB$M_KGE;
    stat = sys$find(&rab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    n2 = 0;
    rab.rab$b_rac = RAB$C_SEQ; /* switch to sequential access mode */
    for(;;)
    {
        rab.rab$l_kbf = 0;
        rab.rab$b_ksz = 0;
        rab.rab$b_krf = 0;
        rab.rab$l_rop = 0;
        rab.rab$l_ubf = &d.id[0];
        rab.rab$w_usz = RECSIZ;
        stat = sys$get(&rab, 0, 0);
        if(!(stat & 1)) break;
        if(strcmp(d.id, stopid) > 0) break;
        n2++;
    }
    rab.rab$b_rac = RAB$C_KEY; /* switch back to keyed access mode */
    printf("%d\n", n2);
    /* close */
    stat = sys$disconnect(&rab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    stat = sys$close(&fab, 0, 0);
    if(!(stat & 1)) {
        rms_exit(stat);
    }
    return 0;
}

We note that the C code is more cumbersome than other languages, because it is a pure API usage, while other languages benefit from language builtin support.

      program test
      implicit none
      structure /mydata/
        character*8 id
        integer*4 iv
        real*8 xv
        integer*2 slen
        character*50 sv
      endstructure
      record /mydata/d
      character*8 BLANK_ID
      character*8 id,stopid
      integer*4 DB,NREC,FOR_OFFSET
      integer*4 i,n,n2
      parameter (DB=1,NREC=1000,FOR_OFFSET=4*NREC,BLANK_ID='        ')
c  open
      open(unit=DB,file='testdb.isq',status='old',
     +     recordtype='fixed',form='unformatted',recl=18,
     +     organization='indexed',access='keyed',key=(1:8:character))
c  put data
      do 100 i=1,NREC
        write(d.id,'(A4,I4)') 'Key#',(FOR_OFFSET+i)
        d.iv=i
        d.xv=i
        d.slen=18
        write(d.sv,'(A,I4.4)') 'This is value ',i
        write(unit=DB) d
100   continue
c
      write(id,'(A4,I4)') 'Key#',(FOR_OFFSET + 77)
c  get
      call dump(DB, id)
c  delete
      read(unit=DB,keyge=id,keyid=0) d
      delete(unit=DB)
c  get non-existing
      call dump(DB, id)
c  get and update
      write(id,'(A4,I4)') 'Key#',(FOR_OFFSET + 88)
      call dump(DB,id)
      read(unit=DB,keyeq=id,keyid=0) d
      d.iv=d.iv+1
      d.xv=d.xv+0.1
      d.sv(d.slen+1:d.slen+8)=' updated'
      d.slen=d.slen+8
      rewrite(unit=DB) d
      call dump(DB,id)
c  list all
      n=0
      read(unit=DB,keyge=BLANK_ID,keyid=0,err=300) d
200   if(d.id(1:4).ne.'Key#') then
        write(*,*) 'Unexpected key: ',d.id
      endif
      if(d.iv.lt.1.or.NREC.lt.d.iv) then
        write(*,*) 'Unexpected value: ',
     +             '(',d.iv,',',d.xv,',',d.sv(1:d.slen),')'
      endif
      n=n+1
      read(unit=DB,end=300) d
      goto 200
300   write(*,*) n
c  list keys where "Key#n075" <= key < "Key#n085"
      write(id,'(A4,I4)') 'Key#',(FOR_OFFSET+75)
      write(stopid,'(A4,I4)') 'Key#',(FOR_OFFSET+85)
      n2=0
      read(unit=DB,keyge=id,keyid=0,err=500) d
400   if(d.id.ge.stopid) goto 500
      n2=n2+1
      read(unit=DB,end=500) d
      goto 400
500   write(*,*) n2
c  close
      close(unit=DB)
      end
c
      subroutine dump(u,id)
      implicit none
      integer*4 u
      character*8 id
      structure /mydata/
        character*8 id
        integer*4 iv
        real*8 xv
        integer*2 slen
        character*50 sv
      endstructure
      record /mydata/d
      write(*,*) 'Key=',id
      read(unit=u,keyeq=id,keyid=0,err=100) d
      write(*,*) '(',d.iv,',',d.xv,',',d.sv(1:d.slen),')'
      return
100   write(*,*) 'Not found'
      return
      end

VMS Python comes with an IndexedFile module capable of accessing index-sequential files and a construct module capable of mapping between a native record format and Python data objects.

from construct import *
from vms.rms.IndexedFile import IndexedFile

from extras import *

class Data:
    def __init__(self, id, iv, xv, sv):
        self.id = id
        self.iv = iv
        self.xv = xv
        self.slen = len(sv.rstrip())
        self.sv = sv.ljust(50)
    def update_sv(self, sv):
        self.slen = len(sv.rstrip())
        self.sv = sv.ljust(50)
    def __str__(self):
        return '(%d, %f, %s)' % (self.iv, self.xv, self.sv.rstrip())

class DataFil(IndexedFile):
    def __init__(self, fnm):
        IndexedFile.__init__(self, fnm, Struct('data', String('id', 8), SNInt32('iv'), VAXGFloat('xv'), UNInt16('slen'), String('sv', 50)))
    def primary_keynum(self):
        return 0
    def pack_key(self, keynum, keyval):
        return keyval
    def keyval(self, rec, keynum):
        return rec.id

def toData(obj):
    return Data(obj.id, obj.iv, obj.xv, obj.sv)

def dump(db, id):
    print('Key=%s' % (id))
    d = db.fetch(0, id)
    if d != None:
        d = toData(d)
        print(d)
    else:
        print('Not found')

NREC = 1000
PY_OFFSET = 7 * NREC
# open
db = DataFil('testdb.isq')
# put data
for i in range(NREC):
    d = Data('Key#' + str(PY_OFFSET + i + 1), i + 1, i + 1.0, 'This is value %d' % (PY_OFFSET + i + 1))
    db.put(d)
#
id = 'Key#' + str(PY_OFFSET + 77)
# get
dump(db, id)
# delete
db.delete(0, id)
# get non-existing
dump(db, id)
# get and update
id = 'Key#' + str(PY_OFFSET + 88)
dump(db, id)
d = db.fetch(0, id)
d = toData(d)
d.iv = d.iv + 1
d.xv = d.xv + 0.1
d.update_sv(d.sv[0:d.slen] + ' updated')
db.update(d)
dump(db, id)
# list all
n = 0
for d in db:
    d = toData(d)
    if not d.id.startswith('Key#'):
        print('Unexpected key: ' + d.id)
    if d.iv < 1 or NREC < d.iv:
        print('Unexpected value: ' + d)
    n = n + 1
print(n)
# list keys where "Key#n075" <= key < "Key#n085"
n2 = 0
for i in range(10): # hack - there should be a better way, but I can't find it
    d = db.fetch(0, 'Key#' + str(PY_OFFSET + 75 + i))
    if d != None:
        d = toData(d)
        n2 = n2 + 1
print(n2)

extras.py (with additions to construct moule for VAX floating point and packed decimals support):

from ctypes import CDLL, c_double, c_char_p, cast, byref
from construct import Adapter, Bytes
from vms.rms import BCD2Tuple, Tuple2BCD
from decimal import Decimal

CVT_K_VAX_F = 0
CVT_K_VAX_D = 1
CVT_K_VAX_G = 2
CVT_K_VAX_H = 3
CVT_K_IEEE_S = 4
CVT_K_IEEE_T = 5
CVT_K_IBM_LONG = 6
CVT_K_IBM_SHORT = 7
CVT_K_CRAY = 8

librtl = CDLL('LIBRTL.EXE')
lib_convert_float = getattr(librtl, 'CVT$CONVERT_FLOAT')

def float_to_python(val, typ):
    res = c_double()
    lib_convert_float(cast(val, c_char_p), typ, byref(res), CVT_K_IEEE_T, 0)
    return res.value

def float_from_python(val, typ):
    res = '12345678'
    lib_convert_float(byref(c_double(val)), CVT_K_IEEE_T, cast(res, c_char_p), typ, 0)
    return res

class VAXFFloatAdapter(Adapter):
    def _decode(self, obj, context):
        return float_to_python(obj, CVT_K_VAX_F)
    def _encode(self, obj, context):
        return float_from_python(obj, CVT_K_VAX_F)

def VAXFFloat(name):
    return VAXFFloatAdapter(Bytes(name, 4))

class VAXDFloatAdapter(Adapter):
    def _decode(self, obj, context):
        return float_to_python(obj, CVT_K_VAX_D)
    def _encode(self, obj, context):
        return float_from_python(obj, CVT_K_VAX_D)

def VAXDFloat(name):
    return VAXDFloatAdapter(Bytes(name, 8))

class VAXGFloatAdapter(Adapter):
    def _decode(self, obj, context):
        return float_to_python(obj, CVT_K_VAX_G)
    def _encode(self, obj, context):
        return float_from_python(obj, CVT_K_VAX_G)

def VAXGFloat(name):
    return VAXGFloatAdapter(Bytes(name, 8))

class PackedDecimalAdapter(Adapter):
    def __init__(self, byts, befdec, aftdec):
        Adapter.__init__(self, byts)
        self.befdec = befdec
        self.aftdec = aftdec
    def _decode(self, obj, context):
        return Decimal(BCD2Tuple(obj, self.aftdec))
    def _encode(self, obj, context):
        return Tuple2BCD(obj.as_tuple(), self.befdec, self.aftdec)

def PackedDecimal(name, befdec, aftdec):
    return PackedDecimalAdapter(Bytes(name, (befdec + aftdec + 2) / 2), befdec, aftdec)

Java cannot call a native API like RMS directly. There need to be a conversion layer utilizing JNI.

Instead of using a custom layer then the code will be using my ISAM library.

import dk.vajhoej.isam.KeyField;
import dk.vajhoej.record.Alignment;
import dk.vajhoej.record.Endian;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;

@Struct(endianess=Endian.LITTLE, alignment=Alignment.ALIGN1)
public class Data {
    @KeyField(n=0)
    @StructField(n=0, type=FieldType.FIXSTRNULTERM, length=8)
    private String id;
    @StructField(n=1, type=FieldType.INT4)
    private int iv;
    @StructField(n=2, type=FieldType.FP8)
    private double xv;
    @StructField(n=3, type=FieldType.VARFIXSTR, length=50)
    private String sv;
    public Data() {
        this("", 0, 0.0, "");
    }
    public Data(String id, int iv, double xv, String sv) {
        super();
        this.id = id;
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public String getId() {
        return id;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

import dk.vajhoej.isam.IsamException;
import dk.vajhoej.isam.IsamResult;
import dk.vajhoej.isam.IsamSource;
import dk.vajhoej.isam.Key0;
import dk.vajhoej.isam.local.LocalIsamSource;
import dk.vajhoej.record.RecordException;

public class Test {
    private static void dump(IsamSource db, String id) throws IsamException, RecordException {
        System.out.printf("Key=%s\n", id);
        Data d = db.read(Data.class, new Key0<String>(id));
        if(d != null) {
            System.out.println(d);
        } else {
            System.out.println("Not found");
        }
    }
    private static final int NREC = 1000;
    private static final int JAVA_OFFSET = 6 * NREC;
    public static void main(String[] args) throws IsamException, RecordException {
        try {
            // open
            IsamSource db = new LocalIsamSource("testdb.isq", "dk.vajhoej.vms.rms.IndexSequential", false);
            // put data
            for(int i = 0; i < NREC; i++) {
                Data d = new Data("Key#" + (JAVA_OFFSET + i + 1), i + 1, i + 1.0, String.format("This is value %d", i + 1));
                db.create(d);
            }
            //
            Data d;
            String id;
            id = "Key#" + (JAVA_OFFSET + 77);
            // get
            dump(db, id);
            // delete
            db.delete(Data.class, new Key0<String>(id));
            // get non existing
            dump(db, id);
            // get and update
            id = "Key#" + (JAVA_OFFSET + 88);
            dump(db, id);
            d = db.read(Data.class, new Key0<String>(id));
            d.setIv(d.getIv() + 1);
            d.setXv(d.getXv() +  0.1);
            d.setSv(d.getSv() + " updated");
            db.update(d);
            dump(db, id);
            // list all
            IsamResult<Data> it = db.readGE(Data.class, new Key0<String>("       "));
            int n = 0;
            while(it.read()) {
                d = it.current();
                if(!d.getId().startsWith("Key#")) {
                    System.out.println("Unexpected key: " + d.getId());
                }
                if(d.getIv() < 1 || NREC < d.getIv()) {
                    System.out.println("Unexpected value :" + d);
                }
                n++;
            }
            System.out.println(n);
            // list keys where "Key#n075" <= key < "Key#n085"
            IsamResult<Data> it2 = db.readGE(Data.class, new Key0<String>("Key#" + (JAVA_OFFSET + 75)));
            int n2 = 0;
            while(it2.read()) {
                d = it2.current();
                if(d.getId().compareTo("Key#" + (JAVA_OFFSET + 85)) >= 0) break;
                n2++;
            }
            System.out.println(n2);
            // close
            db.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

Jython (JVM Python) can use the same library as Java.

It is easiest to keep the data class in Java.

import dk.vajhoej.isam.KeyField;
import dk.vajhoej.record.Alignment;
import dk.vajhoej.record.Endian;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;

@Struct(endianess=Endian.LITTLE, alignment=Alignment.ALIGN1)
public class Data {
    @KeyField(n=0)
    @StructField(n=0, type=FieldType.FIXSTRNULTERM, length=8)
    private String id;
    @StructField(n=1, type=FieldType.INT4)
    private int iv;
    @StructField(n=2, type=FieldType.FP8)
    private double xv;
    @StructField(n=3, type=FieldType.VARFIXSTR, length=50)
    private String sv;
    public Data() {
        this("", 0, 0.0, "");
    }
    public Data(String id, int iv, double xv, String sv) {
        super();
        this.id = id;
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public String getId() {
        return id;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

from dk.vajhoej.isam import Key0
from dk.vajhoej.isam.local import LocalIsamSource

import Data

def dump(db, id):
    print('Key=%s' % (id))
    d = db.read(Data, Key0(id))
    if d != None:
        print(d)
    else:
        print('Not found')

NREC = 1000
PY_OFFSET = 7 * NREC
# open
db = LocalIsamSource('testdb.isq', 'dk.vajhoej.vms.rms.IndexSequential', False)
# put data
for i in range(NREC):
    d = Data('Key#' + str(PY_OFFSET + i + 1), i + 1, i + 1.0, 'This is value %d' % (PY_OFFSET + i + 1))
    db.create(d)
#
id = 'Key#' + str(PY_OFFSET + 77)
# get
dump(db, id)
# delete
db.delete(Data,Key0(id))
# get non-existing
dump(db, id)
# get and update
id = 'Key#' + str(PY_OFFSET + 88)
dump(db, id)
d = db.read(Data, Key0(id))
d.iv = d.iv + 1
d.xv = d.xv + 0.1
d.sv = d.sv + ' updated'
db.update(d)
dump(db, id)
# list all
it = db.readGE(Data, Key0('        '))
n = 0
while it.read():
    d = it.current()
    if not d.id.decode().startswith('Key#'):
        print('Unexpected key: ' + d.id)
    if d.iv < 1 or NREC < d.iv:
        print('Unexpected value: ' + d)
    n = n + 1
print(n)
# list keys where "Key#n075" <= key < "Key#n085"
it2 = db.readGE(Data, Key0('Key#' + str(PY_OFFSET + 75)))
n2 = 0
while it2.read():
    d = it2.current()
    if d.id >= ('Key#' + str(PY_OFFSET + 85)):
        break
    n2 = n2 + 1
print(n2)
# close
db.close()

Rhino (JVM JavaScript) can use the same library as Java.

It is easiest to keep the data class in Java.

import dk.vajhoej.isam.KeyField;
import dk.vajhoej.record.Alignment;
import dk.vajhoej.record.Endian;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;

@Struct(endianess=Endian.LITTLE, alignment=Alignment.ALIGN1)
public class Data {
    @KeyField(n=0)
    @StructField(n=0, type=FieldType.FIXSTRNULTERM, length=8)
    private String id;
    @StructField(n=1, type=FieldType.INT4)
    private int iv;
    @StructField(n=2, type=FieldType.FP8)
    private double xv;
    @StructField(n=3, type=FieldType.VARFIXSTR, length=50)
    private String sv;
    public Data() {
        this("", 0, 0.0, "");
    }
    public Data(String id, int iv, double xv, String sv) {
        super();
        this.id = id;
        this.iv = iv;
        this.xv = xv;
        this.sv = sv;
    }
    public String getId() {
        return id;
    }
    public int getIv() {
        return iv;
    }
    public void setIv(int iv) {
        this.iv = iv;
    }
    public double getXv() {
        return xv;
    }
    public void setXv(double xv) {
        this.xv = xv;
    }
    public String getSv() {
        return sv;
    }
    public void setSv(String sv) {
        this.sv = sv;
    }
    @Override
    public String toString() {
        return String.format("{iv: %d, xv: %f, sv: %s}", iv, xv, sv);
    }
}

importClass(Packages.java.lang.System);

function printf() {
    System.out.printf.apply(System.out, arguments);
}

importClass(Packages.dk.vajhoej.isam.Key0);
importClass(Packages.dk.vajhoej.isam.local.LocalIsamSource);

importClass(Packages.Data);

function dump(db, id) {
    printf("Key=%s\n", id);
    d = db.read(Data, new Key0(id));
    if(d != null) {
        print(d);
    } else {
        print("Not found");
    }
}

NREC = 1000;
JS_OFFSET = 8 * NREC;
// open
db = new LocalIsamSource("testdb.isq", "dk.vajhoej.vms.rms.IndexSequential", false);
// put data
for(i = 0; i < NREC; i++) {
    d = new Data("Key#" + (JS_OFFSET + i + 1), i + 1, i + 1.0, "This is value " + (JS_OFFSET + i + 1));
    db.create(d);
}
//
id = "Key#" + (JS_OFFSET + 77);
// get
dump(db, id);
// delete
db.delete(Data, new Key0(id));
// get non-existing
dump(db, id);
// get and update
id = "Key#" + (JS_OFFSET + 88);
dump(db, id);
d = db.read(Data, new Key0(id));
d.iv = d.iv + 1;
d.xv = d.xv + 0.1;
d.sv = d.sv + " updated";
db.update(d);
dump(db, id);
// list all
it = db.readGE(Data, new Key0("        "));
n = 0;
while(it.read()) {
    d = it.current();
    if(!d.id.startsWith("Key#")) {
        print("Unexpected key: " + d.id);
    }
    if(d.iv < 1 || NREC < d.iv) {
        print("Unexpected value: " + d);
    }
    n = n + 1;
}
print(n);
// list keys where "Key#n075" <= key < "Key#n085"
it2 = db.readGE(Data, Key0("Key#" + (JS_OFFSET + 75)));
n2 = 0;
while(it2.read()) {
    d = it2.current();
    if(d.id >= ("Key#" + (JS_OFFSET + 85))) break;
    n2 = n2 + 1;
}
print(n2);
// close
db.close();

DCL (VMS shell) is capable of accessing index-sequential files.

$ NREC = 1000
$ DCL_OFFSET = 5 * NREC
$! open
$ open/read/write db testdb.isq
$! put
$ i = 0
$ loop0:
$    if i .ge. NREC then goto endloop0
$    id = "Key#" + f$string(DCL_OFFSET + i + 1)
$    iv = i + 1
$    xv = "XXXXXXXX" ! no FP support in DCL
$    sv = "This is value " + f$string(DCL_OFFSET + i + 1)
$    str_iv[0,32] = iv
$    str_slen[0,16] = f$length(sv)
$    rec = id + str_iv + xv + str_slen + sv + f$extract(0, 50 - f$length(sv), "                                                  ")
$    write db rec
$    i = i + 1
$    goto loop0
$ endloop0:
$!
$ id = "Key#" + f$string(DCL_OFFSET + 77)
$! get
$ call dump
$! delete
$ read/index=0/key="''id'"/delete db rec
$! get non-existing
$ call dump
$! update
$ id = "Key#" + f$string(DCL_OFFSET + 88)
$ call dump
$ read/index=0/key="''id'" db rec
$ xid = f$extract(0, 8, rec)
$ iv = f$cvsi(0, 32, f$extract(8, 4, rec))
$ xv = f$extract(12, 8, rec) ! no FP support in DCL
$ slen = f$cvsi(0, 16, f$extract(20, 2, rec))
$ sv = f$extraxt(22, slen, rec)
$ iv = iv + 1
$ ! can't change xv
$ sv = sv + " updated"
$ str_iv[0,32] = iv
$ str_slen[0,16] = f$length(sv)
$ rec = xid + str_iv + xv + str_slen + sv + f$extract(0, 50 - f$length(sv), "                                                  ")
$ write/update db rec
$ call dump
$! close
$ close db
$! list all
$ open/read db testdb.isq
$ n = 0
$ loop1:
$    read/error=endloop1 db rec
$    xid = f$extract(0, 8, rec)
$    if f$locate("Key#", xid) .ne. 0
$    then
$       write sys$output f$fao("Unexpected key: !AS", xid)
$    endif
$    iv = f$cvsi(0, 32, f$extract(8, 4, rec))
$    if iv .lt. 1 .or. NREC .lt. iv
$    then
$       sv = f$edit(f$extraxt(20, f$length(rec) - 20, rec), "TRIM")
$       write sys$output f$fao("Unexpected value: (!AS,!SL,!AS)", xid, iv, sv)
$    endif
$    n = n + 1
$    goto loop1
$ endloop1:
$ write sys$output n
$ close db
$! list keys where "Key#n075" <= key < "Key#n085"
$ open/read db testdb.isq
$ id = "Key#" + f$string(DCL_OFFSET + 75 - 1)
$ read/index=0/key="''id'" db rec
$ n2 = 0
$ loop2:
$    read/error=endloop2 db rec
$    xid = f$extract(0, 8, rec)
$    if xid .ges. "Key#" + f$string(DCL_OFFSET + 85) then goto endloop2
$    n2 = n2 + 1
$    goto loop2
$ endloop2:
$ write sys$output n2
$ close db
$!
$ exit
$!
$ dump: subroutine
$ write sys$output f$fao("Key=!AS", id)
$ read/index=0/key="''id'"/error=notf db rec
$    xid = f$extract(0, 8, rec)
$    iv = f$cvsi(0, 32, f$extract(8, 4, rec))
$    xv = f$extract(12, 8, rec) ! no FP support in DCL
$    slen = f$cvsi(0, 16, f$extract(20, 2, rec))
$    sv = f$extraxt(22, slen, rec)
$    write sys$output f$fao("(!AS,!SL,?,!AS)", xid, iv, sv)
$    goto finish
$ notf:
$    write sys$output "Not found"
$    goto finish
$ finish:
$ endsubroutine

IDENTIFICATION DIVISION.
PROGRAM-ID.MULKEY.

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT OPTIONAL DATA-FILE ASSIGN TO "mulkeydb.isq"
                              ORGANIZATION IS INDEXED
                              ACCESS MODE IS DYNAMIC
                              RECORD KEY IS DATA-ID
                              ALTERNATE RECORD KEY IS DATA-NAME WITH DUPLICATES
                              ALTERNATE RECORD KEY IS DATA-ADDR WITH DUPLICATES.


DATA DIVISION.
FILE SECTION.
FD DATA-FILE.
01 DATA-RECORD.
    03 DATA-ID PIC S9(8) COMP.
    03 DATA-NAME PIC X(32).
    03 DATA-ADDR PIC X(32).
    03 DATA-VAL PIC S9(8) COMP.
WORKING-STORAGE SECTION.
01 TEMP PIC S9(8) DISPLAY.

PROCEDURE DIVISION.
MAIN-PARAGRAPH.
    OPEN I-O DATA-FILE
* lookup by id
    MOVE 2 TO DATA-ID
    READ DATA-FILE
        INVALID KEY DISPLAY "Error reading"
        NOT INVALID KEY CONTINUE
    END-READ
    MOVE DATA-VAL TO TEMP
    DISPLAY TEMP
    MOVE 3 TO DATA-ID
    READ DATA-FILE
        INVALID KEY DISPLAY "Error reading"
        NOT INVALID KEY CONTINUE
    END-READ
    MOVE DATA-VAL TO TEMP
    DISPLAY TEMP
* lookup by name
    MOVE "B" TO DATA-NAME
    READ DATA-FILE KEY IS DATA-NAME
        INVALID KEY DISPLAY "Error reading"
        NOT INVALID KEY CONTINUE
    END-READ
    MOVE DATA-VAL TO TEMP
    DISPLAY TEMP
    MOVE "C" TO DATA-NAME
    READ DATA-FILE KEY IS DATA-NAME
        INVALID KEY DISPLAY "Error reading"
        NOT INVALID KEY CONTINUE
    END-READ
    MOVE DATA-VAL TO TEMP
    DISPLAY TEMP
* lookup by addr
    MOVE "B B B" TO DATA-ADDR
    READ DATA-FILE KEY IS DATA-ADDR
        INVALID KEY DISPLAY "Error reading"
        NOT INVALID KEY CONTINUE
    END-READ
    MOVE DATA-VAL TO TEMP
    DISPLAY TEMP
    MOVE "C C C" TO DATA-ADDR
    READ DATA-FILE KEY IS DATA-ADDR
        INVALID KEY DISPLAY "Error reading"
        NOT INVALID KEY CONTINUE
    END-READ
    MOVE DATA-VAL TO TEMP
    DISPLAY TEMP
*
    CLOSE DATA-FILE
    STOP RUN.

import dk.vajhoej.isam.KeyField;
import dk.vajhoej.isam.IsamSource;
import dk.vajhoej.isam.Key0;
import dk.vajhoej.isam.Key1;
import dk.vajhoej.isam.Key2;
import dk.vajhoej.isam.local.LocalIsamSource;
import dk.vajhoej.record.Alignment;
import dk.vajhoej.record.Endian;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;

public class MulKey {
    @Struct(endianess=Endian.LITTLE, alignment=Alignment.ALIGN1)
    public static class BaseData {
        @KeyField(n=0)
        @StructField(n=0, type=FieldType.INT4)
        private int id;
        @KeyField(n=1)
        @StructField(n=1, type=FieldType.FIXSTR, length=32)
        private String name;
        @KeyField(n=2)
        @StructField(n=2, type=FieldType.FIXSTR, length=32)
        private String address;
        @StructField(n=3, type=FieldType.INT4)
        private int value;
        public BaseData() {
            this(0, "", "", 0);
        }
        public BaseData(int id, String name, String address, int value) {
            super();
            this.id = id;
            this.name = name;
            this.address = address;
            this.value = value;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getAddress() {
            return address;
        }
        public void setAddress(String address) {
            this.address = address;
        }
        public int getValue() {
            return value;
        }
        public void setValue(int value) {
            this.value = value;
        }
    }
    public static void main(String[] args) throws Exception {
        // open
        IsamSource db = new LocalIsamSource("mulkeydb.isq", "dk.vajhoej.vms.rms.IndexSequential", false);
        // lookup by id
        System.out.println(db.read(BaseData.class, new Key0(2)).getValue());
        System.out.println(db.read(BaseData.class, new Key0(3)).getValue());
        // lookup by name
        System.out.println(db.read(BaseData.class, new Key1("B")).getValue());
        System.out.println(db.read(BaseData.class, new Key1("C")).getValue());
        // lookup by address
        System.out.println(db.read(BaseData.class, new Key2("B B B")).getValue());
        System.out.println(db.read(BaseData.class, new Key2("C C C")).getValue());
        // close
        db.close();
    }
}

$ javac -cp /isamdir/isam.jar:/isamdir/record.jar MulKey.java
$ java -cp .:/isamdir/isam.jar:/isamdir/isam-vms.jar:/isamdir/record.jar "MulKey"