sqlite3_opt_serialize.go

//go:build !libsqlite3 || sqlite_serialize
// +build !libsqlite3 sqlite_serialize

package sqlite3

// #ifndef USE_LIBSQLITE3
// #include <sqlite3-binding.h>
// #else
// #include <sqlite3.h>
// #endif /* USE_LIBSQLITE3 */
// #include <stdlib.h>
// #include <stdint.h>
import "C"

import (
	"errors"
	"fmt"
	"math"
	"unsafe"
)

// Serialize returns a byte slice that is a serialization of the database.
//
// See https://www.sqlite.org/c3ref/serialize.html
func (c *SQLiteConn) Serialize(schema string) ([]byte, error) {
	if schema == "" {
		schema = "main"
	}
	zSchema := C.CString(schema)
	defer C.free(unsafe.Pointer(zSchema))

	var sz C.sqlite3_int64
	ptr := C.sqlite3_serialize(c.db, zSchema, &sz, 0)
	if ptr == nil {
		return nil, errors.New(`sqlite3: failed to serialize: "` + schema + `"`)
	}
	defer C.sqlite3_free(unsafe.Pointer(ptr))

	if int64(sz) > math.MaxInt {
		return nil, fmt.Errorf("sqlite3: serialized database is too large (%d bytes)", int64(sz))
	}

	buf := unsafe.Slice((*byte)(unsafe.Pointer(ptr)), sz)
	res := make([]byte, len(buf))
	copy(res, buf)
	return res, nil
}

// Deserialize causes the connection to disconnect from the current database and
// then re-open as an in-memory database based on the contents of the byte slice.
//
// See https://www.sqlite.org/c3ref/deserialize.html
func (c *SQLiteConn) Deserialize(b []byte, schema string) error {
	if schema == "" {
		schema = "main"
	}
	zSchema := C.CString(schema)
	defer C.free(unsafe.Pointer(zSchema))

	tmp := (*C.uchar)(C.sqlite3_malloc64(C.sqlite3_uint64(len(b))))
	buf := unsafe.Slice((*byte)(unsafe.Pointer(tmp)), len(b))
	copy(buf, b)
	rc := C.sqlite3_deserialize(c.db, zSchema, tmp, C.sqlite3_int64(len(b)),
		C.sqlite3_int64(len(b)), C.SQLITE_DESERIALIZE_FREEONCLOSE)
	if rc != C.SQLITE_OK {
		return fmt.Errorf("deserialize failed with return %v", rc)
	}
	return nil
}