view release on metacpan or  search on metacpan

lib/RocksDB.xs  view on Meta::CPAN

        if (val = hv_fetchs(options, "reduce_level", 0))
            reduce_level = SvTRUE(*val);
        if (val = hv_fetchs(options, "target_level", 0))
            target_level = SvIV(*val);
    }
    THIS->db->CompactRange(b ? &sbegin : NULL, e ? &send : NULL, reduce_level, target_level);

int
RocksDB::DB::number_levels()
CODE:
    RETVAL = THIS->db->NumberLevels();
OUTPUT:
    RETVAL

int
RocksDB::DB::max_mem_compaction_level()
CODE:
    RETVAL = THIS->db->MaxMemCompactionLevel();
OUTPUT:
    RETVAL

int
RocksDB::DB::level0_stop_write_trigger()
CODE:
    RETVAL = THIS->db->Level0StopWriteTrigger();
OUTPUT:
    RETVAL

void
RocksDB::DB::flush(HV *options = NULL)
CODE:
    rocksdb::FlushOptions opts = rocksdb::FlushOptions();
    if (options)
        apply_flush_options(aTHX_ &opts, options);
    CROAK_ON_ERROR(THIS->db->Flush(opts));

void
RocksDB::DB::disable_file_deletions()
CODE:
    THIS->db->DisableFileDeletions();

void
RocksDB::DB::enable_file_deletions()
CODE:
    THIS->db->EnableFileDeletions();

void
RocksDB::DB::delete_file(const char* name)
CODE:
    THIS->db->DeleteFile(name);

rocksdb::SequenceNumber
RocksDB::DB::get_latest_sequence_number()
CODE:
    RETVAL = THIS->db->GetLatestSequenceNumber();
OUTPUT:
    RETVAL

void
RocksDB::DB::get_live_files_meta_data()
PPCODE:
    std::vector<rocksdb::LiveFileMetaData> metadata;
    THIS->db->GetLiveFilesMetaData(&metadata);
    for (std::vector<rocksdb::LiveFileMetaData>::size_type i = 0; i < metadata.size(); i++) {
        rocksdb::LiveFileMetaData data = metadata[i];
        HV *hv = newHV();
        hv_stores(hv, "name", newSVpvn(data.name.c_str(), data.name.size()));
        hv_stores(hv, "level", newSViv(data.level));
        hv_stores(hv, "size", newSViv(data.size));
        hv_stores(hv, "smallestkey", newSVpvn(data.smallestkey.c_str(), data.smallestkey.size()));
        hv_stores(hv, "largestkey", newSVpvn(data.largestkey.c_str(), data.largestkey.size()));
        hv_stores(hv, "smallest_seqno", newSVnv(data.smallest_seqno));
        hv_stores(hv, "largest_seqno", newSVnv(data.largest_seqno));
        mXPUSHs(newRV_noinc((SV*) hv));
    }

void
RocksDB::DB::get_sorted_wal_files()
PPCODE:
    rocksdb::VectorLogPtr files;
    CROAK_ON_ERROR(THIS->db->GetSortedWalFiles(files));
    for (std::vector<std::unique_ptr<rocksdb::LogFile>>::size_type i = 0; i < files.size(); i++) {
        HV* hv = newHV();
        std::string path_name = files[i]->PathName();
        hv_stores(hv, "path_name", newSVpvn(path_name.c_str(), path_name.size()));
        hv_stores(hv, "log_number", newSViv(files[i]->LogNumber()));
        SV* type;
        if (files[i]->Type() == rocksdb::WalFileType::kArchivedLogFile) {
            type = newSVpvs("archived");
        } else { /* kAliveLogFile */
            type = newSVpvs("alive");
        }
        hv_stores(hv, "type", type);
        hv_stores(hv, "start_sequence", newSViv(files[i]->StartSequence()));
        hv_stores(hv, "size_file_bytes", newSViv(files[i]->SizeFileBytes()));
        mXPUSHs(newRV_noinc((SV*) hv));
    }

RocksDB::TransactionLogIterator*
RocksDB::DB::get_updates_since(rocksdb::SequenceNumber seq_number)
PREINIT:
    const char* CLASS = "RocksDB::TransactionLogIterator";
CODE:
    auto iter = new RocksDB::TransactionLogIterator();
    rocksdb::Status status = THIS->db->GetUpdatesSince(seq_number, &iter->ptr);
    if (!status.ok()) {
        delete iter;
        CROAK_ON_ERROR(status);
    }
    RETVAL = iter;
OUTPUT:
    RETVAL

std::string
RocksDB::DB::get_db_identity()
CODE:
    std::string identity;
    CROAK_ON_ERROR(THIS->db->GetDbIdentity(identity));
    RETVAL = identity;
OUTPUT:
    RETVAL

RocksDB::Statistics*
RocksDB::DB::get_statistics()
PREINIT:
    const char* CLASS = "RocksDB::Statistics";
CODE:
    if (THIS->db->GetOptions().statistics != NULL) {
        RETVAL = new RocksDB::Statistics(THIS->db->GetOptions().statistics);
    } else {
        RETVAL = NULL;
    }
OUTPUT:
    RETVAL

void
RocksDB::DB::CLEAR()
CODE:
    rocksdb::Iterator* it = THIS->db->NewIterator(rocksdb::ReadOptions());

lib/RocksDB.xs  view on Meta::CPAN

CLEANUP:
    DESTROY_ROCKSDB_OBJ(SELF);

MODULE = RocksDB        PACKAGE = RocksDB::Iterator

SV*
rocksdb::Iterator::seek_to_first()
CODE:
    THIS->SeekToFirst();
    RETVAL = SvREFCNT_inc_simple_NN(SELF);
OUTPUT:
    RETVAL

SV*
rocksdb::Iterator::seek_to_last()
CODE:
    THIS->SeekToLast();
    RETVAL = SvREFCNT_inc_simple_NN(SELF);
OUTPUT:
    RETVAL

SV*
rocksdb::Iterator::seek(rocksdb::Slice target)
CODE:
    THIS->Seek(target);
    RETVAL = SvREFCNT_inc_simple_NN(SELF);
OUTPUT:
    RETVAL

void
rocksdb::Iterator::next()
CODE:
    CHECK_ITER_VALID(THIS);
    THIS->Next();

void
rocksdb::Iterator::prev()
CODE:
    CHECK_ITER_VALID(THIS);
    THIS->Prev();

bool
rocksdb::Iterator::valid()
CODE:
    RETVAL = THIS->Valid();
OUTPUT:
    RETVAL

rocksdb::Slice
rocksdb::Iterator::key()
INIT:
    CHECK_ITER_VALID(THIS);

rocksdb::Slice
rocksdb::Iterator::value()
INIT:
    CHECK_ITER_VALID(THIS);

void
rocksdb::Iterator::each()
PPCODE:
    if (!THIS->Valid())
        XSRETURN_EMPTY;
    rocksdb::Slice key = THIS->key(), value = THIS->value();
    mXPUSHs(newSVpvn(key.data(), key.size()));
    mXPUSHs(newSVpvn(value.data(), value.size()));
    THIS->Next();

void
rocksdb::Iterator::reverse_each()
PPCODE:
    if (!THIS->Valid())
        XSRETURN_EMPTY;
    rocksdb::Slice key = THIS->key(), value = THIS->value();
    mXPUSHs(newSVpvn(key.data(), key.size()));
    mXPUSHs(newSVpvn(value.data(), value.size()));
    THIS->Prev();

void
rocksdb::Iterator::DESTROY()
CLEANUP:
    DESTROY_ROCKSDB_OBJ(SELF);

MODULE = RocksDB        PACKAGE = RocksDB::WriteBatch

rocksdb::WriteBatch *
rocksdb::WriteBatch::new()

void
rocksdb::WriteBatch::put(rocksdb::Slice key, rocksdb::Slice value)
CODE:
    THIS->Put(key, value);

void
rocksdb::WriteBatch::merge(rocksdb::Slice key, rocksdb::Slice value)
CODE:
    THIS->Merge(key, value);

void
rocksdb::WriteBatch::remove(rocksdb::Slice key)
ALIAS:
    RocksDB::WriteBatch::delete = 1
CODE:
    THIS->Delete(key);

void
rocksdb::WriteBatch::put_log_data(rocksdb::Slice blob)
CODE:
    THIS->PutLogData(blob);

int
rocksdb::WriteBatch::count()
CODE:
    RETVAL = THIS->Count();
OUTPUT:
    RETVAL

std::string
rocksdb::WriteBatch::data()
CODE:
    RETVAL = THIS->Data();
OUTPUT:
    RETVAL

void
rocksdb::WriteBatch::clear()
CODE:
    THIS->Clear();

void
rocksdb::WriteBatch::iterate(RocksDB::WriteBatchHandler* handler)