Class: MTBL::Writer

Inherits:

Object

• Object
• MTBL::Writer

Defined in:

ext/mtbl/ruby-mtbl.c

Instance Method Summary

• #add(key, val) ⇒ Object
• #close ⇒ Object
• #initialize(*args) ⇒ Object constructor

Constructor Details

#initialize(*args) ⇒ Object

# File 'ext/mtbl/ruby-mtbl.c', line 237

static VALUE rbmtbl_writer_initialize(int argc, VALUE *argv, VALUE self) {
    rbmtbl_writer_t *writer;
    struct stat ss;
    int scanc;
    VALUE fname, ctype, bsize, rinterval;

    Data_Get_Struct(self, rbmtbl_writer_t, writer);

    scanc = rb_scan_args(argc, argv, "13", &fname, &ctype, &bsize, &rinterval);

    if (scanc > 1) {
        if (TYPE(ctype) != T_FIXNUM) {
          rb_raise(rb_eArgError, "Compression type should be a constant (COMPRESSION_NONE, etc)");
          return Qnil;
        }
        if (FIX2INT(ctype) < MTBL_COMPRESSION_NONE || FIX2INT(ctype) > MTBL_COMPRESSION_LZ4HC) {
            rb_raise(rb_eArgError, "Invalid compression type: %d", FIX2INT(ctype));
            return Qnil;
        }
        mtbl_writer_options_set_compression(writer->o, FIX2INT(ctype));
    }

    if (scanc > 2) {
        if (TYPE(bsize) != T_FIXNUM) {
            rb_raise(rb_eArgError, "Block size should be an integer");
            return Qnil;
        }
      mtbl_writer_options_set_block_size(writer->o, FIX2INT(bsize));
    }

    if (scanc > 3) {
        if (TYPE(rinterval) != T_FIXNUM) {
            rb_raise(rb_eArgError, "Restart interval should be an integer");
            return Qnil;
        }
      mtbl_writer_options_set_block_restart_interval(writer->o, FIX2INT(rinterval));
    }

    if (TYPE(fname) != T_STRING) {
        rb_raise(rb_eArgError, "File name must be a string");
        return Qnil;
    }

    if (! stat(StringValueCStr(fname), &ss)) {
        rb_raise(rb_eArgError, "File already exists: %s", StringValueCStr(fname));
        return Qnil;
    }

    writer->w = mtbl_writer_init(StringValueCStr(fname), writer->o);
    if (writer->w == NULL) {
        rb_raise(rb_eRuntimeError, "Failed to open %s", StringValueCStr(fname));
        return Qnil;
    }
    return self;
}

Instance Method Details

#add(key, val) ⇒ Object

# File 'ext/mtbl/ruby-mtbl.c', line 293

static VALUE rbmtbl_writer_add(VALUE self, VALUE key, VALUE val) {
    rbmtbl_writer_t *writer;
    Data_Get_Struct(self, rbmtbl_writer_t, writer);
    if (! writer->w) {
        rb_raise(rb_eRuntimeError, "Failed to write key %s: writer closed", StringValueCStr(key));
        return Qnil;
    }

    if (TYPE(key) != T_STRING) {
        rb_raise(rb_eArgError, "Key must be a string");
        return Qnil;
    }

    if (TYPE(val) != T_STRING) {
        rb_raise(rb_eArgError, "Value must be a string");
        return Qnil;
    }

    if( mtbl_res_success != mtbl_writer_add(writer->w,
        (const uint8_t *) RSTRING_PTR(key), RSTRING_LEN(key),
        (const uint8_t *) RSTRING_PTR(val), RSTRING_LEN(val))) {
        rb_raise(rb_eRuntimeError, "Failed to write key %s, input must be presorted", StringValueCStr(key));
        return Qnil;
    }
    return Qtrue;
}

#close ⇒ Object

# File 'ext/mtbl/ruby-mtbl.c', line 320

static VALUE rbmtbl_writer_close(VALUE self) {
    rbmtbl_writer_t *writer;
    Data_Get_Struct(self, rbmtbl_writer_t, writer);
    if (writer->w) {
        rbmtbl_writer_close_handles(writer);
        return Qtrue;
    } else {
        rb_raise(rb_eRuntimeError, "Writer is already closed");
        return Qfalse;
    }
}