Simple Integration,Multi-Language Support

Via C ABI header (talon.h) and talon_execute JSON universal entry point, one function call to access all engines. Go SDK ready, others in progress.

View C ABI Docs arrow_forward

Examples

open_in_new View on GitHub

main.go

Go 1.21+

package main

import (
    "fmt"
    "log"
    talon "github.com/darkmice/talon-sdk/go"
)

func main() {
    db, err := talon.Open("./my_data")
    if err != nil { log.Fatal(err) }
    defer db.Close()

    // SQL 引擎
    db.RunSQL("CREATE TABLE users (id INT PRIMARY KEY, name TEXT, score REAL)")
    db.RunSQL("INSERT INTO users VALUES (1, 'Alice', 95.5)")

    // KV 引擎
    db.KvSet([]byte("session:u1"), []byte("active"), 3600)

    // talon_execute JSON 通用入口
    result, _ := db.Execute(`{"module":"sql","action":"query",
        "params":{"sql":"SELECT * FROM users LIMIT 10"}}`)
    fmt.Println(result)
}

terminal Output / Console

$ go run main.go

[INFO] Talon opened: ./my_data SQL: CREATE TABLE ok SQL INSERT: 1 row affected KV SET: session:u1 OK (TTL=3600s) {"ok":true,"data":[[1,"Alice",95.5]]} Process finished with exit code 0

Examples

open_in_new View on GitHub

main.rs

Rust 2021

use talon::{Store, sql, kv::KvEngine};

fn main() -> Result<(), talon::Error> {
    let store = Store::open("./my_data")?;

    sql::run(&store, "CREATE TABLE users (id INT PK, name TEXT, score REAL)")?;
    sql::run(&store, "INSERT INTO users VALUES (1, 'Alice', 95.5)")?;

    let kv = KvEngine::open(&store)?;
    kv.set(b"session:u1", b"active", 3600)?;

    let rows = sql::run(&store, "SELECT * FROM users")?;
    println!("{:?}", rows);
    Ok(())
}

terminal Output / Console

$ cargo run --release

[INFO] Compiling talon-demo v0.1.0 [INFO] Finished release [optimized] [[1, "Alice", 95.5]] Process finished with exit code 0

Examples

open_in_new View on GitHub

main.py

Python 3.9+

import ctypes, json

lib = ctypes.CDLL("./libtalon.dylib")
lib.talon_open.restype = ctypes.c_void_p
db = lib.talon_open(b"./my_data")
out = ctypes.c_char_p()

# SQL + KV + Execute 综合示例
cmd = json.dumps({"module":"sql","action":"query","params":{"sql":"SELECT * FROM users LIMIT 10"}}).encode()
lib.talon_execute(db, cmd, ctypes.byref(out))
print(out.value.decode())
lib.talon_free_string(out)
lib.talon_close(db)

terminal Output / Console

$ python main.py

[INFO] Loaded libtalon {"ok":true,"data":[[1,"Alice",95.5]]} Process finished with exit code 0

Examples

open_in_new View on GitHub

index.mjs

Node 18+

import ffi from 'ffi-napi';
import ref from 'ref-napi';

const talon = ffi.Library('./libtalon', {
  'talon_open': ['pointer', ['string']],
  'talon_execute': ['int', ['pointer', 'string', ref.refType('string')]],
  'talon_close': ['void', ['pointer']],
});
const db = talon.talon_open('./my_data');
const out = ref.alloc('string');

// SQL + KV + Execute 综合示例
talon.talon_execute(db, JSON.stringify({"module":"sql","action":"query","params":{"sql":"SELECT * FROM users LIMIT 10"}}), out);
console.log(out.deref());
talon.talon_close(db);

terminal Output / Console

$ node index.mjs

[INFO] Loaded libtalon {"ok":true,"data":[[1,"Alice",95.5]]} Process finished with exit code 0

Examples

open_in_new View on GitHub

Main.java

Java 17+

import com.sun.jna.*;
import com.sun.jna.ptr.PointerByReference;

public class Main {
    public interface Talon extends Library {
        Talon LIB = Native.load("talon", Talon.class);
        Pointer talon_open(String p);
        int talon_execute(Pointer h, String cmd, PointerByReference out);
        void talon_close(Pointer h);
        void talon_free_string(Pointer p);
    }
    public static void main(String[] args) {
        Pointer db = Talon.LIB.talon_open("./my_data");
        PointerByReference out = new PointerByReference();

        // SQL + KV + Execute 综合示例
        Talon.LIB.talon_execute(db, "{\"module\":\"sql\",\"action\":\"query\",\"params\":{\"sql\":\"SELECT * FROM users LIMIT 10\"}}", out);
        System.out.println(out.getValue().getString(0));
        Talon.LIB.talon_free_string(out.getValue());
        Talon.LIB.talon_close(db);
    }
}

terminal Output / Console

$ javac Main.java && java Main

[INFO] Loaded libtalon {"ok":true,"data":[[1,"Alice",95.5]]} Process finished with exit code 0

Examples

open_in_new View on GitHub

main.c

C11 / C++17

#include <stdio.h>
#include "talon.h"

int main() {
    TalonHandle *db = talon_open("./my_data");
    char *json = NULL;

    // SQL + KV + Execute 综合示例
    talon_execute(db, "{\"module\":\"sql\",\"action\":\"query\",\"params\":{\"sql\":\"SELECT * FROM users LIMIT 10\"}}", &json);
    printf("%s\n", json);
    talon_free_string(json);
    talon_close(db);
    return 0;
}

terminal Output / Console

$ gcc main.c -ltalon -o demo && ./demo

[INFO] Loaded libtalon {"ok":true,"data":[[1,"Alice",95.5]]} Process finished with exit code 0

Examples

open_in_new View on GitHub

Program.cs

.NET 8+

using System;
using System.Runtime.InteropServices;

class Talon {
    [DllImport("talon")] static extern IntPtr talon_open(string p);
    [DllImport("talon")] static extern int talon_execute(IntPtr h, string cmd, out IntPtr json);
    [DllImport("talon")] static extern void talon_close(IntPtr h);
    [DllImport("talon")] static extern void talon_free_string(IntPtr p);

    static void Main() {
        var db = talon_open("./my_data");
        IntPtr json;

        // SQL + KV + Execute 综合示例
        talon_execute(db, @"{""module"":""sql"",""action"":""query"",""params"":{""sql"":""SELECT * FROM users LIMIT 10""}}", out json);
        Console.WriteLine(Marshal.PtrToStringAnsi(json));
        talon_free_string(json);
        talon_close(db);
    }
}

terminal Output / Console

$ dotnet run

[INFO] Loaded libtalon {"ok":true,"data":[[1,"Alice",95.5]]} Process finished with exit code 0

speed

Unified JSON Entry

talon_execute — one function covers all engines. Input JSON command, get JSON result. No need to learn multiple APIs.

security

C ABI Zero-Dep

Link libtalon.so/dylib and go. Any language with C FFI support (Go/Python/Java/C#) can integrate directly.

hub

Embedded Zero-Overhead

In embedded mode, direct memory calls with no network round-trips or serialization. PK query latency <0.02ms.

Ready to build next-gen applications?

Get Started Free View Docs