Coverage report: /home/ellis/comp/core/lib/rdb/rocksdb.lisp

Kind	Covered	All	%
expression	367	1178	31.2
branch	3	6	50.0

Key

Not instrumented

Conditionalized out

Executed

Not executed

Both branches taken

One branch taken

Neither branch taken

1

;;; rdb/raw.lisp --- Intermediate API to ROCKSDB aliens

2

3

;;; Code:

4

(in-package :rdb)

5

6

;;; Options

7

(defun make-rocksdb-options (&optional init-fn)

8

"Make and return RDB-OPTS. INIT-FN is an optional argument which must be a

9

lambda which takes a single parameter (the RDB-OPTS sap). It is used

10

to initialize the instance with custom configuration."

11

(let ((opts (rocksdb-options-create)))

12

(when init-fn (funcall init-fn opts))

13

opts))

14

15

(defun default-rocksdb-options ()

16

(make-rocksdb-options

17

(lambda (o) (rocksdb-options-set-create-if-missing o t))))

18

19

(defun load-opts-raw (dir)

20

(rocksdb::with-latest-options dir (db-opts names cf-opts)

21

(values db-opts names cf-opts)))

22

23

(defun get-stats-raw (opt htype)

24

(with-alien ((hist (* rocksdb-statistics-histogram-data) (rocksdb-statistics-histogram-data-create)))

25

(rocksdb-options-statistics-get-histogram-data opt htype hist)

26

hist))

27

28

;;; DB

29

(defun open-db-raw (db-path &optional (opts (default-rocksdb-options)))

30

(with-errptr* (err 'open-db-error :db db-path)

31

(let* ((db-path (if (pathnamep db-path)

32

(namestring db-path)

33

db-path)))

34

(rocksdb-open opts db-path err))))

35

36

(defun close-db-raw (db)

37

(rocksdb-close db))

38

39

(defun destroy-db-raw (path &optional (opt (rocksdb-options-create)))

40

(with-errptr* (err 'destroy-db-error :db path)

41

(rocksdb-destroy-db opt (namestring (uiop:ensure-directory-pathname path)) err)

42

(rocksdb-options-destroy opt)))

43

44

(defun get-metadata-raw (db &optional cf)

45

(if cf

46

(rocksdb-get-column-family-metadata-cf db cf)

47

(rocksdb-get-column-family-metadata db)))

48

49

(defun flush-db-raw (db &optional wait)

50

(with-errptr* (err 'flush-db-error :db db)

51

(let ((opts (rocksdb-flushoptions-create)))

52

(when wait (rocksdb-flushoptions-set-wait opts wait))

53

(rocksdb-flush db opts err))))

54

55

(defun repair-db-raw (name &optional (opts (rocksdb-options-create)))

56

(with-errptr* (err 'repair-db-error :name name)

57

(rocksdb-repair-db opts name err)))

58

59

(defun ingest-db-raw (db files &optional (opts (rocksdb-ingestexternalfileoptions-create)))

60

(let ((flen (length files)))

61

(with-errptr* (err 'ingest-db-error)

62

(with-alien ((flist (* c-string) (make-alien c-string flen)))

63

(loop for f in files

64

for i from 0 to flen

65

do (setf (deref flist i) (make-alien-string f :null-terminate t)))

66

(rocksdb-ingest-external-file db flist flen opts err)))))

67

68

(defun ingest-db-cf-raw (db cf files &optional (opts (rocksdb-ingestexternalfileoptions-create)))

69

(let ((flen (length files)))

70

(with-errptr* (err 'ingest-db-error)

71

(with-alien ((flist (* c-string) (make-alien c-string flen)))

72

(loop for f in files

73

for i from 0 to flen

74

do (setf (deref flist i) (make-alien-string f :null-terminate t)))

75

(rocksdb-ingest-external-file-cf db cf flist flen opts err)))))

76

77

;;; KVs

78

(defun put-kv-raw (db key val &optional (opts (rocksdb-writeoptions-create)))

79

(with-kv-raw (db key e :error put-kv-error :val val)

80

(rocksdb-put db opts

81

%key %klen

82

%val %vlen

83

e)))

84

85

(defun put-kv-str-raw (db key val &optional (opts (rocksdb-writeoptions-create)))

86

(let ((key-octets (string-to-octets key :null-terminate nil))

87

(val-octets (string-to-octets val :null-terminate nil)))

88

(put-kv-raw db key-octets val-octets opts)))

89

90

(defun get-kv-raw (db key &optional (opt (rocksdb-readoptions-create)) pinned)

91

(with-kv-raw (db key e :error get-kv-error)

92

(with-alien ((vlen size-t))

93

(let* ((val (if pinned

94

(rocksdb-get-pinned db opt %key %klen e)

95

(rocksdb-get db

96

opt

97

%key

98

%klen

99

(addr vlen)

100

e))))

101

;; helps if we know the vlen beforehand, would need a custom

102

;; C-side function probably.

103

(let ((v (make-octets vlen)))

104

(clone-octets-from-alien val v vlen)

105

(coerce v 'octet-vector))))))

106

107

(defun get-kv-str-raw (db key &optional (opt (rocksdb-readoptions-create)) pinned)

108

(let ((k (string-to-octets key)))

109

(let ((v (get-kv-raw db k opt pinned)))

110

(when v (octets-to-string v)))))

111

112

(defun multi-get-kv-raw (db keys &optional (opt (rocksdb-readoptions-create)))

113

(multiple-value-bind (keys keyns) (clone-octet-vector-list* keys)

114

(let ((n (length keys)))

115

(with-alien ((vals (* c-string) (make-alien c-string n))

116

(valns (* size-t) (make-alien size-t n))

117

(errs (* rocksdb-errptr) (make-alien rocksdb-errptr n)))

118

(rocksdb-multi-get db opt n keys keyns vals valns errs)))))

119

120

(defun multi-get-kv-str-raw (db keys &optional (opt (rocksdb-readoptions-create)))

121

(let ((n (length keys))

122

(keys (clone-strings keys nil))

123

(keyns (clone-integer-list (mapcar 'length keys))))

124

(with-alien ((vals (* c-string) (make-alien c-string n))

125

(valns (* size-t) (make-alien size-t n))

126

(errs (* rocksdb-errptr) (make-alien rocksdb-errptr n)))

127

(rocksdb-multi-get db opt n keys keyns vals valns errs))))

128

129

(defun multi-get-cf-kv-raw (db cfs keys &optional (opt (rocksdb-readoptions-create)))

130

(multiple-value-bind (keys keyns) (clone-octet-vector-list* keys)

131

(let ((n (length keys)))

132

       (with-alien ((%cfs (* (* rocksdb-column-family-handle)) (make-alien (* rocksdb-column-family-handle) n))

133

(vals (* (* (unsigned 8))) (make-alien (* (unsigned 8)) n))

134

(valns (* size-t) (make-alien size-t n))

135

(errs (* rocksdb-errptr) (make-alien rocksdb-errptr n)))

136

(loop for i below n do (setf (deref %cfs i) (pop cfs)))

137

(rocksdb-multi-get-cf db opt cfs n keys keyns vals valns errs)))))

138

139

(defun multi-get-cf-kv-str-raw (db cfs keys &optional (opt (rocksdb-readoptions-create)))

140

(let ((n (length keys))

141

(keys (clone-strings keys nil))

142

(keyns (clone-integer-list (mapcar 'length keys))))

143

     (with-alien ((%cfs (* (* rocksdb-column-family-handle)) (make-alien (* rocksdb-column-family-handle) n))

144

(vals (* (* (unsigned 8))) (make-alien (* (unsigned 8)) n))

145

(valns (* size-t) (make-alien size-t n))

146

(errs (* rocksdb-errptr) (make-alien rocksdb-errptr n)))

147

(loop for i below n do (setf (deref %cfs i) (pop cfs)))

148

(rocksdb-multi-get-cf db opt cfs n keys keyns vals valns errs))))

149

150

(defun merge-kv-raw (db key val &optional (opt (rocksdb-writeoptions-create)))

151

(with-kv-raw (db key e :error merge-kv-error :val val)

152

(rocksdb-merge db opt %key %klen %val %vlen e)))

153

154

(defun merge-kv-str-raw (db key val &optional (opt (rocksdb-writeoptions-create)))

155

(let ((k (string-to-octets key))

156

(v (string-to-octets val)))

157

(merge-kv-raw db k v opt)))

158

159

;;; Column Family

160

(defun open-cfs-raw (db-opt name names opts)

161

(let ((n (length names)))

162

(with-alien ((cf-names (* c-string) (clone-strings names))

163

(cf-opts (* (* rocksdb-options)) (make-alien (* rocksdb-options) n))

164

                  (cf-handles (* (* rocksdb-column-family-handle)) (make-alien (* rocksdb-column-family-handle) n)))

165

(loop for opt in opts

166

for i below n

167

do (setf (deref cf-opts i) opt))

168

(with-errptr* (err 'cf-error :cf name)

169

(let ((db (rocksdb-open-column-families db-opt name n cf-names cf-opts cf-handles err)))

170

(values db cf-handles))))))

171

172

(defun create-cf-raw (db name &optional (opt (rocksdb-options-create)))

173

(with-errptr* (err 'cf-error :db db :cf name)

174

(rocksdb-create-column-family db opt name err)))

175

176

(defun destroy-cf-raw (cf)

177

(rocksdb-column-family-handle-destroy cf))

178

179

(defun get-cf-raw (db cf key &optional (opt (rocksdb-readoptions-create)) pinned)

180

(with-kv-raw (db key e :error get-kv-cf-error :cf cf)

181

(with-alien ((vlen (* size-t) (make-alien size-t)))

182

(let ((val (if pinned

183

(rocksdb-get-pinned db opt %key %klen e)

184

(rocksdb-get-cf db

185

opt

186

cf

187

%key

188

%klen

189

vlen

190

e)))

191

;; helps if we know the vlen beforehand, would need a custom

192

;; C-side function probably.

193

(v (make-array (deref vlen) :element-type 'octet)))

194

(let ((ret (clone-octets-from-alien val v (deref vlen))))

195

(unless (zerop (length ret))

196

ret))))))

197

198

(defun get-cf-str-raw (db cf key &optional (opt (rocksdb-readoptions-create)) pinned)

199

(let ((k (string-to-octets key :null-terminate nil)))

200

(let ((v (get-cf-raw db cf k opt pinned)))

201

(when v (octets-to-string v)))))

202

203

(defun put-cf-raw (db cf key val &optional (opts (rocksdb-writeoptions-create)))

204

(with-kv-raw (db key e :error put-kv-cf-error :val val :cf cf)

205

(rocksdb-put-cf db

206

opts

207

cf

208

%key %klen

209

%val %vlen

210

e)))

211

212

(defun put-cf-str-raw (db cf key val &optional (opt (rocksdb-writeoptions-create)))

213

(let ((key-octets (string-to-octets key :null-terminate nil))

214

(val-octets (string-to-octets val :null-terminate nil)))

215

(put-cf-raw db cf key-octets val-octets opt)))

216

217

(defun merge-cf-raw (db cf key val &optional (opt (rocksdb-writeoptions-create)))

218

(with-kv-raw (db key e :cf cf :error merge-kv-error :val val)

219

(rocksdb-merge-cf db opt cf %key %klen %val %vlen e)))

220

221

(defun merge-cf-str-raw (db cf key val &optional (opt (rocksdb-writeoptions-create)))

222

(let ((k (string-to-octets key))

223

(v (string-to-octets val)))

224

(merge-cf-raw db cf k v opt)))

225

226

(defun cf-name-raw (cf-handle)

227

(rocksdb-column-family-handle-get-name cf-handle (make-alien unsigned-long)))

228

229

(defun cf-id-raw (cf-handle)

230

(rocksdb-column-family-handle-get-id cf-handle))

231

232

;;; Iterators

233

(defun create-iter-raw (db &optional (opt (rocksdb-readoptions-create)))

234

(rocksdb-create-iterator db opt))

235

236

(defun create-cf-iter-raw (db cf &optional (opt (rocksdb-readoptions-create)))

237

(rocksdb-create-iterator-cf db opt cf))

238

239

(defun destroy-iter-raw (iter)

240

(rocksdb-iter-destroy iter))

241

242

(defun iter-key-raw (iter)

243

(with-alien ((klen-ptr (* size-t) (make-alien size-t 0)))

244

(let* ((key-ptr (rocksdb-iter-key iter klen-ptr))

245

(klen (deref klen-ptr))

246

(k (make-array klen :element-type '(unsigned-byte 8))))

247

(clone-octets-from-alien key-ptr k klen)

248

k)))

249

250

(defun iter-key-str-raw (iter)

251

(when-let ((k (iter-key-raw iter)))

252

(octets-to-string k)))

253

254

(defun iter-val-raw (iter)

255

(with-alien ((vlen-ptr (* size-t) (make-alien size-t 0)))

256

(let* ((val-ptr (rocksdb-iter-value iter vlen-ptr))

257

(vlen (deref vlen-ptr))

258

(v (make-array vlen :element-type '(unsigned-byte 8))))

259

(clone-octets-from-alien val-ptr v vlen)

260

v)))

261

262

(defun iter-val-str-raw (iter)

263

(when-let ((v (iter-val-raw iter)))

264

(octets-to-string v)))

265

266

;;; Backup DB

267

(defun open-backup-engine-raw (be-path &optional (opts (rocksdb-backup-engine-options-create)))

268

(with-errptr* (err 'open-backup-db-error :db be-path)

269

(let ((be-path (if (pathnamep be-path)

270

(namestring be-path)

271

be-path)))

272

(rocksdb-backup-engine-options-set-backup-dir opts be-path)

273

(rocksdb-backup-engine-open opts be-path err))))

274

275

(defun close-backup-engine-raw (be)

276

(rocksdb-backup-engine-close be))

277

278

(defun create-new-backup-raw (be db)

279

(with-errptr* (err 'rdb-alien-error)

280

(rocksdb-backup-engine-create-new-backup be db err)))

281

282

(defun restore-from-latest-backup-raw (be db-path backup-path &optional (opt (rocksdb-restore-options-create)))

283

(with-errptr* (err 'open-db-error)

284

(rocksdb-backup-engine-restore-db-from-latest-backup be db-path backup-path opt err)))

285

286

 (defun restore-from-backup-raw (be db-path backup-path backup-id &optional (opt (rocksdb-restore-options-create)))

287

(with-errptr* (err 'open-db-error)

288

(rocksdb-backup-engine-restore-db-from-backup be db-path backup-path opt backup-id err)))

289

290

;;; Snapshot

291

(defun create-snapshot-raw (db)

292

(rocksdb-create-snapshot db))

293

294

(defun release-snapshot-raw (db snapshot)

295

(rocksdb-release-snapshot db snapshot))

296

297

;;; SST

298

 (defun create-sst-writer-raw (&optional (env-opts (rocksdb-envoptions-create)) (io-opts (rocksdb-options-create)))

299

(rocksdb-sstfilewriter-create env-opts io-opts))

300

301

(defun create-sst-writer-with-comparator-raw (comparator

302

&optional

303

                                                 (env-opts (rocksdb-envoptions-create))

304

                                                 (io-opts (rocksdb-options-create)))

305

(rocksdb-sstfilewriter-create-with-comparator env-opts io-opts comparator))

306

307

(defun finish-sst-writer-raw (writer)

308

(with-errptr* (err 'rdb-alien-error)

309

(rocksdb-sstfilewriter-finish writer err)))

310

311

(defun destroy-sst-writer-raw (writer)

312

(rocksdb-sstfilewriter-destroy writer))

313

314

(defun open-sst-writer-raw (writer name)

315

(with-errptr* (err 'rdb-alien-error)

316

(rocksdb-sstfilewriter-open writer name err)))

317

318

;; this function is deprecated in the Java API:

319

;; https://javadoc.io/doc/org.rocksdb/rocksdbjni/6.6.4/org/rocksdb/SstFileWriter.html

320

;; (defun sst-add-raw (writer key val)

321

;; (with-errptr* (err 'rdb-alien-error)

322

;; (rocksdb-sstfilewriter-add writer key (length key) val (length val) err)))

323

324

(defun sst-put-raw (writer key val)

325

(let ((klen (length key))

326

(vlen (length val)))

327

(with-errptr* (err 'rdb-alien-error)

328

(with-alien ((k (* unsigned-char) (make-alien unsigned-char klen))

329

(v (* unsigned-char) (make-alien unsigned-char vlen)))

330

(setfa k key)

331

(setfa v val)

332

(rocksdb-sstfilewriter-put writer k klen v vlen err)))))

333

334

(defun sst-put-str-raw (writer key val)

335

(let ((key-octets (string-to-octets key :null-terminate nil))

336

(val-octets (string-to-octets val :null-terminate nil)))

337

(sst-put-raw writer key-octets val-octets)))

338

339

(defun sst-put-ts-raw (writer key val ts)

340

(with-errptr* (err 'rdb-alien-error)

341

(rocksdb-sstfilewriter-put-with-ts writer key (length key) val (length val) ts (length ts) err)))

342

343

(defun sst-delete-raw (writer key)

344

(with-errptr* (err 'rdb-alien-error)

345

(rocksdb-sstfilewriter-delete writer key (length key) err)))

346

347

(defun sst-delete-ts-raw (writer key ts)

348

(with-errptr* (err 'rdb-alien-error)

349

(rocksdb-sstfilewriter-delete-with-ts writer key (length key) ts (length ts) err)))

350

351

(defun sst-delete-range-raw (writer start-key end-key)

352

(with-errptr* (err 'rdb-alien-error)

353

     (rocksdb-sstfilewriter-delete-range writer start-key (length start-key) end-key (length end-key) err)))

354

355

(defun sst-file-size-raw (writer)

356

(with-errptr* (err 'rdb-alien-error)

357

(with-alien ((ret unsigned-long))

358

(rocksdb-sstfilewriter-file-size writer (addr ret) err)

359

ret)))

360

361

;;; Transactions

362

(defun open-transactiondb-raw (opts topts name)

363

(with-errptr* (e 'open-db-error :db name)

364

(rocksdb-transactiondb-open opts topts name e)))

365

366

(defun open-optimistictransactiondb-raw (opts name)

367

(with-errptr* (e 'open-db-error :db name)

368

(rocksdb-optimistictransactiondb-open opts name e)))

369

370

(defun transactiondb-get-kv-raw (db key &optional (opts (rocksdb-readoptions-create)) pinned)

371

(with-kv-raw (db key e :error get-kv-error)

372

(with-alien ((vlen (* size-t)))

373

(let* ((val (if pinned

374

(rocksdb-transactiondb-get-pinned db opts %key %klen e)

375

(rocksdb-transactiondb-get db opts %key %klen vlen e)))

376

(v (make-array (deref vlen) :element-type 'octet)))

377

(clone-octets-from-alien val v (deref vlen))

378

v))))

379

380

(defun transactiondb-get-kv-str-raw (db key &optional (opts (rocksdb-readoptions-create)) pinned)

381

(let ((k (string-to-octets key)))

382

(let ((v (transactiondb-get-kv-raw db k opts pinned)))

383

(when v (octets-to-string v)))))

384

385

(defun transactiondb-get-cf-raw (db cf key &optional (opts (rocksdb-readoptions-create)) pinned)

386

(with-kv-raw (db key e :error get-kv-cf-error :cf cf)

387

(with-alien ((vlen (* size-t)))

388

(let* ((val (if pinned

389

(rocksdb-transactiondb-get-pinned-cf db opts cf %key %klen e)

390

(rocksdb-transactiondb-get-cf db opts cf %key %klen vlen e)))

391

(v (make-array (deref vlen) :element-type 'octet)))

392

(clone-octets-from-alien val v (deref vlen))

393

v))))

394

395

(defun transactiondb-get-cf-str-raw (db cf key &optional (opts (rocksdb-readoptions-create)) pinned)

396

(let ((k (string-to-octets key)))

397

(let ((v (transactiondb-get-cf-raw db cf k opts pinned)))

398

(when v (octets-to-string v)))))

399

400

(defun transactiondb-put-kv-raw (db key val &optional (opts (rocksdb-writeoptions-create)))

401

(with-kv-raw (db key e :error put-kv-error :val val)

402

(rocksdb-transactiondb-put db opts %key %klen %val %vlen e)))

403

404

(defun transactiondb-put-kv-str-raw (db key val &optional (opts (rocksdb-writeoptions-create)))

405

(let ((key-octets (string-to-octets key :null-terminate nil))

406

(val-octets (string-to-octets val :null-terminate nil)))

407

(transactiondb-put-kv-raw db key-octets val-octets opts)))

408

409

(defun transactiondb-put-cf-raw (db cf key val &optional (opts (rocksdb-writeoptions-create)))

410

(with-kv-raw (db key e :error put-kv-cf-error :val val :cf cf)

411

(rocksdb-transactiondb-put-cf db

412

opts

413

cf

414

%key %klen

415

%val %vlen

416

e)))

417

418

(defun transactiondb-put-cf-str-raw (db cf key val &optional (opts (rocksdb-writeoptions-create)))

419

(let ((key-octets (string-to-octets key :null-terminate nil))

420

(val-octets (string-to-octets val :null-terminate nil)))

421

(transactiondb-put-cf-raw db cf key-octets val-octets opts)))

422

423

(defun commit-transaction-raw (txn)

424

(with-errptr* (e 'rdb-alien-error)

425

(rocksdb-transaction-commit txn e)))

426

427

(defun rollback-transaction-raw (txn &optional savepoint)

428

"Rollback a raw transaction TXN when SAVEPOINT is non-nil only rollback to last

429

savepoint created with ROCKSDB-TRANSACTION-SET-SAVEPOINT."

430

(with-errptr* (e 'rdb-alien-error)

431

(if savepoint

432

(rocksdb-transaction-rollback-to-savepoint txn e)

433

(rocksdb-transaction-rollback txn e))))

434

435

(defun prepare-transaction-raw (txn)

436

(with-errptr* (e 'rdb-alien-error)

437

(rocksdb-transaction-prepare txn e)))

438

439

(defun transaction-name-raw (txn)

440

(with-errptr* (e 'rdb-alien-error)

441

(with-alien ((len size-t))

442

(let ((name (rocksdb-transaction-get-name txn (addr len)))

443

(ret (make-octets len)))

444

(octets-to-string (clone-octets-from-alien name ret len))))))

445

446

(defun set-transaction-name-raw (txn name)

447

(with-errptr* (e 'rdb-alien-error)

448

(let ((nlen (length name)))

449

(with-alien ((%name (* unsigned-char) (octets-to-alien (string-to-octets name))))

450

(rocksdb-transaction-set-name txn %name nlen e)))))

451

452

(defsetf transaction-name-raw set-transaction-name-raw)

453

454

(defun transaction-get-raw (txn key &optional (opts (rocksdb-readoptions-create)) pinned)

455

(with-txn-raw (txn e :key key)

456

(with-alien ((vlen size-t))

457

(if pinned

458

(rocksdb-transaction-get-pinned txn opts %key %klen e)

459

(rocksdb-transaction-get txn opts %key %klen (addr vlen) e)))))

460

461

(defun transaction-get-cf-raw (txn cf key &optional (opts (rocksdb-readoptions-create)) pinned)

462

(with-txn-raw (txn e :key key :cf cf)

463

(with-alien ((vlen size-t))

464

(if pinned

465

(rocksdb-transaction-get-pinned-cf txn opts cf %key %klen e)

466

(rocksdb-transaction-get-cf txn opts cf %key %klen (addr vlen) e)))))

467

468

(defun transaction-delete-raw (txn key)

469

(with-txn-raw (txn e :key key)

470

(rocksdb-transaction-delete txn %key %klen e)))

471

472

(defun transaction-delete-cf-raw (txn cf key)

473

(with-txn-raw (txn e :key key :cf cf)

474

(rocksdb-transaction-delete-cf txn cf %key %klen e)))

475

476

(defun transaction-put-raw (txn key val)

477

(with-txn-raw (txn e :key key :val val)

478

(rocksdb-transaction-put txn %key %klen %val %vlen e)))

479

480

(defun transaction-put-cf-raw (txn cf key val)

481

(with-txn-raw (txn e :cf cf :key key :val val)

482

(rocksdb-transaction-put-cf txn cf %key %klen %val %vlen e)))

483

484

(defun transaction-merge-raw (txn key val)

485

(with-txn-raw (txn e :key key :val val)

486

(rocksdb-transaction-merge txn %key %klen %val %vlen e)))

487

488

(defun transaction-merge-cf-raw (txn cf key val)

489

(with-txn-raw (txn e :key key :val val :cf cf)

490

(rocksdb-transaction-merge-cf txn cf %key %klen %val %vlen e)))

491

492

(defun get-prepared-transactions-raw (txn-db)

493

"Return an array of prepared ROCKSDB-TRANSACTION pointers from this

494

transaction-db."

495

(with-errptr* (e 'rdb-alien-error)

496

(with-alien ((cnt size-t))

497

(rocksdb-transactiondb-get-prepared-transactions txn-db (addr cnt)))))

498

499

;;; Checkpoints

500

(defun make-checkpoint-raw (db)

501

(with-errptr* (e 'rdb-alien-error)

502

(rocksdb-checkpoint-object-create db e)))

503

504

(defun create-checkpoint-raw (chk dir &optional log-size-for-flush)

505

(with-errptr* (e 'rdb-alien-error)

506

(rocksdb-checkpoint-create chk dir log-size-for-flush e)))

507

508

;;; Secondary

509

(defun open-db-secondary-raw (opts name sname)

510

(with-errptr* (e 'rdb-alien-error)

511

(rocksdb-open-as-secondary opts name sname e)))

512

513

(defun open-cfs-secondary-raw (opts name sname cf-names cf-opts)

514

(with-errptr* (e 'rdb-alien-error)

515

(with-alien ((cf-handles (* (* rocksdb-column-family-handle))))

516

(rocksdb-open-as-secondary-column-families

517

opts name sname (length cf-names) cf-names cf-opts cf-handles e))))

518

519

;;; Read-only

520

(defun open-cfs-read-only-raw (opts name cf-names cf-opts &optional err-if-wal)

521

(with-errptr* (e 'rdb-alien-error)

522

(with-alien ((cf-handles (* (* rocksdb-column-family-handle))))

523

(rocksdb-open-for-read-only-column-families

524

opts name (length cf-names) cf-names cf-opts cf-handles err-if-wal e))))

525

526

;;; TTL

527

(defun open-cfs-with-ttl-raw (opts name cf-names cf-opts ttls)

528

(with-errptr* (e 'rdb-alien-error)

529

(with-alien ((cf-handles (* (* rocksdb-column-family-handle))))

530

(rocksdb-open-column-families-with-ttl

531

opts name (length cf-names) cf-names cf-opts cf-handles ttls e))))

532

;;; Merge Ops

533

(defun create-index-merge-op ()

534

(with-alien ((state (* t))

535

                (destructor (* rocksdb-destructor-function) (alien-sap (alien-callable-function 'rocksdb-destructor)))

536

                (full-merge (* rocksdb-full-merge-function) (alien-sap (alien-callable-function 'rocksdb-index-full-merge)))

537

                (partial-merge (* rocksdb-partial-merge-function) (alien-sap (alien-callable-function 'rocksdb-index-partial-merge)))

538

                (delete-value (* rocksdb-delete-value-function) (alien-sap (alien-callable-function 'rocksdb-delete-value)))

539

                (name (* rocksdb-name-function) (alien-sap (alien-callable-function 'rocksdb-index-merge-name))))

540

(rocksdb-mergeoperator-create state destructor full-merge partial-merge delete-value name)))

541

542

(defun create-concat-merge-op ()

543

;; concat merge op

544

(with-alien ((state (* t))

545

                (destructor (* rocksdb-destructor-function) (alien-sap (alien-callable-function 'rocksdb-destructor)))

546

                (full-merge (* rocksdb-full-merge-function) (alien-sap (alien-callable-function 'rocksdb-concat-full-merge)))

547

                (partial-merge (* rocksdb-partial-merge-function) (alien-sap (alien-callable-function 'rocksdb-concat-partial-merge)))

548

                (delete-value (* rocksdb-delete-value-function) (alien-sap (alien-callable-function 'rocksdb-delete-value)))

549

                (name (* rocksdb-name-function) (alien-sap (alien-callable-function 'rocksdb-concat-merge-name))))

550

(rocksdb-mergeoperator-create state destructor full-merge partial-merge delete-value name)))

551

552

;;; Prefix Ops

553

(defun create-fixed-prefix-op (n)

554

(rocksdb-slicetransform-create-fixed-prefix n))

555

556

;;; Logger

557

(defun create-default-logger-callback (&optional (level 0))

558

(rocksdb-logger-create-callback-logger

559

level

560

(alien-sap (alien-callable-function 'rocksdb-log-default)) nil))

561

562

;;; Writebatch/WBWI

563

(defun create-wbwi (&optional (reserved-bytes 0) (overwrite-keys 1))

564

(rocksdb-writebatch-wi-create reserved-bytes overwrite-keys))

565

566

(defun wbwi-put-cf-raw (wbwi cf key val)

567

(with-kv-raw* key val

568

(rocksdb-writebatch-wi-put-cf

569

wbwi

570

cf

571

%key %klen

572

%val %vlen)))