1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
package lmdb
/*
#include <stdlib.h>
#include <stdio.h>
#include "lmdb.h"
*/
import "C"
import (
"unsafe"
"github.com/bmatsuo/lmdb-go/internal/lmdbarch"
)
// valSizeBits is the number of bits which constraining the length of the
// single values in an LMDB database, either 32 or 31 depending on the
// platform. valMaxSize is the largest data size allowed based. See runtime
// source file malloc.go and the compiler typecheck.go for more information
// about memory limits and array bound limits.
//
// https://github.com/golang/go/blob/a03bdc3e6bea34abd5077205371e6fb9ef354481/src/runtime/malloc.go#L151-L164
// https://github.com/golang/go/blob/36a80c5941ec36d9c44d6f3c068d13201e023b5f/src/cmd/compile/internal/gc/typecheck.go#L383
//
// On 64-bit systems, luckily, the value 2^32-1 coincides with the maximum data
// size for LMDB (MAXDATASIZE).
const (
valSizeBits = lmdbarch.Width64*32 + (1-lmdbarch.Width64)*31
valMaxSize = 1<<valSizeBits - 1
)
// Multi is a wrapper for a contiguous page of sorted, fixed-length values
// passed to Cursor.PutMulti or retrieved using Cursor.Get with the
// GetMultiple/NextMultiple flag.
//
// Multi values are only useful in databases opened with DupSort|DupFixed.
type Multi struct {
page []byte
stride int
}
// WrapMulti converts a page of contiguous values with stride size into a
// Multi. WrapMulti panics if len(page) is not a multiple of stride.
//
// _, val, _ := cursor.Get(nil, nil, lmdb.FirstDup)
// _, page, _ := cursor.Get(nil, nil, lmdb.GetMultiple)
// multi := lmdb.WrapMulti(page, len(val))
//
// See mdb_cursor_get and MDB_GET_MULTIPLE.
func WrapMulti(page []byte, stride int) *Multi {
if len(page)%stride != 0 {
panic("incongruent arguments")
}
return &Multi{page: page, stride: stride}
}
// Vals returns a slice containing the values in m. The returned slice has
// length m.Len() and each item has length m.Stride().
func (m *Multi) Vals() [][]byte {
n := m.Len()
ps := make([][]byte, n)
for i := 0; i < n; i++ {
ps[i] = m.Val(i)
}
return ps
}
// Val returns the value at index i. Val panics if i is out of range.
func (m *Multi) Val(i int) []byte {
off := i * m.stride
return m.page[off : off+m.stride]
}
// Len returns the number of values in the Multi.
func (m *Multi) Len() int {
return len(m.page) / m.stride
}
// Stride returns the length of an individual value in the m.
func (m *Multi) Stride() int {
return m.stride
}
// Size returns the total size of the Multi data and is equal to
//
// m.Len()*m.Stride()
//
func (m *Multi) Size() int {
return len(m.page)
}
// Page returns the Multi page data as a raw slice of bytes with length
// m.Size().
func (m *Multi) Page() []byte {
return m.page[:len(m.page):len(m.page)]
}
var eb = []byte{0}
func valBytes(b []byte) ([]byte, int) {
if len(b) == 0 {
return eb, 0
}
return b, len(b)
}
func wrapVal(b []byte) *C.MDB_val {
p, n := valBytes(b)
return &C.MDB_val{
mv_data: unsafe.Pointer(&p[0]),
mv_size: C.size_t(n),
}
}
func getBytes(val *C.MDB_val) []byte {
return (*[valMaxSize]byte)(unsafe.Pointer(val.mv_data))[:val.mv_size:val.mv_size]
}
func getBytesCopy(val *C.MDB_val) []byte {
return C.GoBytes(val.mv_data, C.int(val.mv_size))
}
|
