6067355637

Committed 03 Sep 2023 11:32PM UTC coverage: 66.95% (+0.02%) from 66.93%

Build # 6067355637

Build Type

push

github

Committed by

web-flow

Commit Message

Adapt RocksDB 8.4.4 (#125)

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

3308 of 4941 relevant lines covered (66.95%)

0.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/optimistic_transaction_db.go

package grocksdb

// #include <stdlib.h>
// #include "rocksdb/c.h"
import "C"

import (
        "unsafe"
)

// OptimisticTransactionDB is a reusable handle to a RocksDB optimistic transactional database on disk.
type OptimisticTransactionDB struct {
        c    *C.rocksdb_optimistictransactiondb_t
        name string
        opts *Options
}

// OpenOptimisticTransactionDb opens a database with the specified options.
func OpenOptimisticTransactionDb(
        opts *Options,
        name string,
) (tdb *OptimisticTransactionDB, err error) {
        var (
                cErr  *C.char
                cName = C.CString(name)
        )

        db := C.rocksdb_optimistictransactiondb_open(
                opts.c, cName, &cErr)
        if err = fromCError(cErr); err == nil {
                tdb = &OptimisticTransactionDB{
                        name: name,
                        c:    db,
                        opts: opts,
                }
        }

        C.free(unsafe.Pointer(cName))
        return
}

// OpenOptimisticTransactionDbColumnFamilies opens a database with the specified column families.
func OpenOptimisticTransactionDbColumnFamilies(
        opts *Options,
        name string,
        cfNames []string,
        cfOpts []*Options,
) (db *OptimisticTransactionDB, cfHandles []*ColumnFamilyHandle, err error) {
        numColumnFamilies := len(cfNames)
        if numColumnFamilies != len(cfOpts) {
                err = ErrColumnFamilyMustMatch
                return
        }

        cName := C.CString(name)
        cNames := make([]*C.char, numColumnFamilies)
        for i, s := range cfNames {
                cNames[i] = C.CString(s)
        }

        cOpts := make([]*C.rocksdb_options_t, numColumnFamilies)
        for i, o := range cfOpts {
                cOpts[i] = o.c
        }

        cHandles := make([]*C.rocksdb_column_family_handle_t, numColumnFamilies)

        var cErr *C.char
        _db := C.rocksdb_optimistictransactiondb_open_column_families(
                opts.c,
                cName,
                C.int(numColumnFamilies),
                &cNames[0],
                &cOpts[0],
                &cHandles[0],
                &cErr,
        )
        if err = fromCError(cErr); err == nil {
                db = &OptimisticTransactionDB{
                        name: name,
                        c:    _db,
                        opts: opts,
                }
                cfHandles = make([]*ColumnFamilyHandle, numColumnFamilies)
                for i, c := range cHandles {
                        cfHandles[i] = newNativeColumnFamilyHandle(c)
                }
        }

        C.free(unsafe.Pointer(cName))
        for _, s := range cNames {
                C.free(unsafe.Pointer(s))
        }
        return
}

// TransactionBegin begins a new transaction
// with the WriteOptions and TransactionOptions given.
func (db *OptimisticTransactionDB) TransactionBegin(
        opts *WriteOptions,
        transactionOpts *OptimisticTransactionOptions,
        oldTransaction *Transaction,
) *Transaction {
        if oldTransaction != nil {
                cTx := C.rocksdb_optimistictransaction_begin(
                        db.c,
                        opts.c,
                        transactionOpts.c,
                        oldTransaction.c,
                )
                return newNativeTransaction(cTx)
        }

        cTx := C.rocksdb_optimistictransaction_begin(db.c, opts.c, transactionOpts.c, nil)
        return newNativeTransaction(cTx)
}

// NewCheckpoint creates a new Checkpoint for this db.
func (db *OptimisticTransactionDB) NewCheckpoint() (cp *Checkpoint, err error) {
        var cErr *C.char

        cCheckpoint := C.rocksdb_optimistictransactiondb_checkpoint_object_create(
                db.c, &cErr,
        )
        if err = fromCError(cErr); err == nil {
                cp = newNativeCheckpoint(cCheckpoint)
        }

        return
}

// Write batch.
func (db *OptimisticTransactionDB) Write(opts *WriteOptions, batch *WriteBatch) (err error) {
        var cErr *C.char

        C.rocksdb_optimistictransactiondb_write(db.c, opts.c, batch.c, &cErr)
        err = fromCError(cErr)

        return
}

// Close closes the database.
func (db *OptimisticTransactionDB) Close() {
        C.rocksdb_optimistictransactiondb_close(db.c)
        db.c = nil
}

// GetBaseDB returns base-database.
func (db *OptimisticTransactionDB) GetBaseDB() *DB {
        return &DB{
                c:    C.rocksdb_optimistictransactiondb_get_base_db(db.c),
                name: db.name,
                opts: db.opts,
        }
}

// CloseBaseDB closes base-database.
func (db *OptimisticTransactionDB) CloseBaseDB(base *DB) {
        C.rocksdb_optimistictransactiondb_close_base_db(base.c)
        base.c = nil
}

1	package grocksdb
2
3	// #include <stdlib.h>
4	// #include "rocksdb/c.h"
5	import "C"
6
7	import (
8	"unsafe"
9	)
10
11	// OptimisticTransactionDB is a reusable handle to a RocksDB optimistic transactional database on disk.
12	type OptimisticTransactionDB struct {
13	c *C.rocksdb_optimistictransactiondb_t
14	name string
15	opts *Options
16	}
17
18	// OpenOptimisticTransactionDb opens a database with the specified options.
19	func OpenOptimisticTransactionDb(
20	opts *Options,
21	name string,
22	) (tdb *OptimisticTransactionDB, err error) {	×
23	var (	×
24	cErr *C.char	×
25	cName = C.CString(name)	×
26	)	×
27		×
28	db := C.rocksdb_optimistictransactiondb_open(	×
29	opts.c, cName, &cErr)	×
30	if err = fromCError(cErr); err == nil {	×
31	tdb = &OptimisticTransactionDB{	×
32	name: name,	×
33	c: db,	×
34	opts: opts,	×
35	}	×
36	}	×
37
38	C.free(unsafe.Pointer(cName))	×
39	return	×
40	}
41
42	// OpenOptimisticTransactionDbColumnFamilies opens a database with the specified column families.
43	func OpenOptimisticTransactionDbColumnFamilies(
44	opts *Options,
45	name string,
46	cfNames []string,
47	cfOpts []*Options,
48	) (db OptimisticTransactionDB, cfHandles []ColumnFamilyHandle, err error) {	×
49	numColumnFamilies := len(cfNames)	×
50	if numColumnFamilies != len(cfOpts) {	×
51	err = ErrColumnFamilyMustMatch	×
52	return	×
53	}	×
54
55	cName := C.CString(name)	×
56	cNames := make([]*C.char, numColumnFamilies)	×
57	for i, s := range cfNames {	×
58	cNames[i] = C.CString(s)	×
59	}	×
60
61	cOpts := make([]*C.rocksdb_options_t, numColumnFamilies)	×
62	for i, o := range cfOpts {	×
63	cOpts[i] = o.c	×
64	}	×
65
66	cHandles := make([]*C.rocksdb_column_family_handle_t, numColumnFamilies)	×
67		×
68	var cErr *C.char	×
69	_db := C.rocksdb_optimistictransactiondb_open_column_families(	×
70	opts.c,	×
71	cName,	×
72	C.int(numColumnFamilies),	×
73	&cNames[0],	×
74	&cOpts[0],	×
75	&cHandles[0],	×
76	&cErr,	×
77	)	×
78	if err = fromCError(cErr); err == nil {	×
79	db = &OptimisticTransactionDB{	×
80	name: name,	×
81	c: _db,	×
82	opts: opts,	×
83	}	×
84	cfHandles = make([]*ColumnFamilyHandle, numColumnFamilies)	×
85	for i, c := range cHandles {	×
86	cfHandles[i] = newNativeColumnFamilyHandle(c)	×
87	}	×
88	}
89
90	C.free(unsafe.Pointer(cName))	×
91	for _, s := range cNames {	×
92	C.free(unsafe.Pointer(s))	×
93	}	×
94	return	×
95	}
96
97	// TransactionBegin begins a new transaction
98	// with the WriteOptions and TransactionOptions given.
99	func (db *OptimisticTransactionDB) TransactionBegin(
100	opts *WriteOptions,
101	transactionOpts *OptimisticTransactionOptions,
102	oldTransaction *Transaction,
103	) *Transaction {	×
104	if oldTransaction != nil {	×
105	cTx := C.rocksdb_optimistictransaction_begin(	×
106	db.c,	×
107	opts.c,	×
108	transactionOpts.c,	×
109	oldTransaction.c,	×
110	)	×
111	return newNativeTransaction(cTx)	×
112	}	×
113
114	cTx := C.rocksdb_optimistictransaction_begin(db.c, opts.c, transactionOpts.c, nil)	×
115	return newNativeTransaction(cTx)	×
116	}
117
118	// NewCheckpoint creates a new Checkpoint for this db.
119	func (db OptimisticTransactionDB) NewCheckpoint() (cp Checkpoint, err error) {	×
120	var cErr *C.char	×
121		×
122	cCheckpoint := C.rocksdb_optimistictransactiondb_checkpoint_object_create(	×
123	db.c, &cErr,	×
124	)	×
125	if err = fromCError(cErr); err == nil {	×
126	cp = newNativeCheckpoint(cCheckpoint)	×
127	}	×
128
129	return	×
130	}
131
132	// Write batch.
133	func (db OptimisticTransactionDB) Write(opts WriteOptions, batch *WriteBatch) (err error) {	×
134	var cErr *C.char	×
135		×
136	C.rocksdb_optimistictransactiondb_write(db.c, opts.c, batch.c, &cErr)	×
137	err = fromCError(cErr)	×
138		×
139	return	×
140	}	×
141
142	// Close closes the database.
143	func (db *OptimisticTransactionDB) Close() {	×
144	C.rocksdb_optimistictransactiondb_close(db.c)	×
145	db.c = nil	×
146	}	×
147
148	// GetBaseDB returns base-database.
149	func (db OptimisticTransactionDB) GetBaseDB() DB {	×
150	return &DB{	×
151	c: C.rocksdb_optimistictransactiondb_get_base_db(db.c),	×
152	name: db.name,	×
153	opts: db.opts,	×
154	}	×
155	}	×
156
157	// CloseBaseDB closes base-database.
158	func (db OptimisticTransactionDB) CloseBaseDB(base DB) {	×
159	C.rocksdb_optimistictransactiondb_close_base_db(base.c)	×
160	base.c = nil	×
161	}	×

linxGnu / grocksdb / 6067355637

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous