libcouchbase 0.0.1

data/ext/libcouchbase/src/operations/store.c

@@ -0,0 +1,360 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+#include "internal.h"
+#include "mc/compress.h"
+#include "trace.h"
+#include "durability_internal.h"
+
+typedef struct {
+    mc_REQDATAEX base;
+    lcb_t instance;
+    lcb_U16 persist_to;
+    lcb_U16 replicate_to;
+} DURSTORECTX;
+
+/** Observe stuff */
+static void
+handle_dur_storecb(mc_PIPELINE *pl, mc_PACKET *pkt,
+    lcb_error_t err, const void *arg)
+{
+    lcb_RESPCALLBACK cb;
+    lcb_RESPSTOREDUR resp = { 0 };
+    lcb_CMDENDURE dcmd = { 0 };
+    const lcb_MUTATION_TOKEN *mt;
+    DURSTORECTX *dctx = (DURSTORECTX *)pkt->u_rdata.exdata;
+    lcb_MULTICMD_CTX *mctx;
+    lcb_durability_opts_t opts = { 0 };
+    const lcb_RESPSTORE *sresp = (const lcb_RESPSTORE *)arg;
+
+    if (err != LCB_SUCCESS) {
+        goto GT_BAIL;
+    }
+    if (sresp->rc != LCB_SUCCESS) {
+        err = sresp->rc;
+        goto GT_BAIL;
+    }
+
+    resp.store_ok = 1;
+    LCB_CMD_SET_KEY(&dcmd, sresp->key, sresp->nkey);
+    dcmd.cas = sresp->cas;
+
+    mt = lcb_resp_get_mutation_token(LCB_CALLBACK_STORE, (const lcb_RESPBASE*)sresp);
+    if (LCB_MUTATION_TOKEN_ISVALID(mt)) {
+        dcmd.mutation_token = mt;
+    }
+
+    /* Set the options.. */
+    opts.v.v0.persist_to = dctx->persist_to;
+    opts.v.v0.replicate_to = dctx->replicate_to;
+
+    mctx = lcb_endure3_ctxnew(dctx->instance, &opts, &err);
+    if (mctx == NULL) {
+        goto GT_BAIL;
+    }
+
+    lcbdurctx_set_durstore(mctx, 1);
+    err = mctx->addcmd(mctx, (lcb_CMDBASE*)&dcmd);
+    if (err != LCB_SUCCESS) {
+        mctx->fail(mctx);
+        goto GT_BAIL;
+    }
+    lcb_sched_enter(dctx->instance);
+    err = mctx->done(mctx, sresp->cookie);
+    lcb_sched_leave(dctx->instance);
+
+    if (err == LCB_SUCCESS) {
+        /* Everything OK? */
+        free(dctx);
+        return;
+    }
+
+    GT_BAIL:
+    {
+        lcb_RESPENDURE dresp = { 0 };
+        resp.key = sresp->key;
+        resp.nkey = sresp->nkey;
+        resp.cookie = sresp->cookie;
+        resp.rc = err;
+        resp.dur_resp = &dresp;
+        cb = lcb_find_callback(dctx->instance, LCB_CALLBACK_STOREDUR);
+        cb(dctx->instance, LCB_CALLBACK_STOREDUR, (const lcb_RESPBASE*)&resp);
+        free(dctx);
+    }
+
+    (void)pl;
+}
+
+static void
+handle_dur_schedfail(mc_PACKET *pkt)
+{
+    DURSTORECTX *dctx = (void *)pkt->u_rdata.exdata;
+    free(dctx);
+}
+
+mc_REQDATAPROCS storedur_procs = {
+        handle_dur_storecb,
+        handle_dur_schedfail
+};
+
+static lcb_size_t
+get_value_size(mc_PACKET *packet)
+{
+    if (packet->flags & MCREQ_F_VALUE_IOV) {
+        return packet->u_value.multi.total_length;
+    } else {
+        return packet->u_value.single.size;
+    }
+}
+
+static lcb_error_t
+get_esize_and_opcode(
+        lcb_storage_t ucmd, lcb_uint8_t *opcode, lcb_uint8_t *esize)
+{
+    if (ucmd == LCB_SET || ucmd == LCB_UPSERT) {
+        *opcode = PROTOCOL_BINARY_CMD_SET;
+        *esize = 8;
+    } else if (ucmd == LCB_ADD) {
+        *opcode = PROTOCOL_BINARY_CMD_ADD;
+        *esize = 8;
+    } else if (ucmd == LCB_REPLACE) {
+        *opcode = PROTOCOL_BINARY_CMD_REPLACE;
+        *esize = 8;
+    } else if (ucmd == LCB_APPEND) {
+        *opcode = PROTOCOL_BINARY_CMD_APPEND;
+        *esize = 0;
+    } else if (ucmd == LCB_PREPEND) {
+        *opcode = PROTOCOL_BINARY_CMD_PREPEND;
+        *esize = 0;
+    } else {
+        return LCB_EINVAL;
+    }
+    return LCB_SUCCESS;
+}
+
+
+static int
+can_compress(lcb_t instance, const mc_PIPELINE *pipeline,
+    const lcb_VALBUF *vbuf, lcb_datatype_t datatype)
+{
+    mc_SERVER *server = (mc_SERVER *)pipeline;
+    int compressopts = LCBT_SETTING(instance, compressopts);
+
+    if (mcreq_compression_supported() == 0) {
+        return 0;
+    }
+
+    if (vbuf->vtype != LCB_KV_COPY) {
+        return 0;
+    }
+    if ((compressopts & LCB_COMPRESS_OUT) == 0) {
+        return 0;
+    }
+    if (server->compsupport == 0 && (compressopts & LCB_COMPRESS_FORCE) == 0) {
+        return 0;
+    }
+    if (datatype & LCB_VALUE_F_SNAPPYCOMP) {
+        return 0;
+    }
+    return 1;
+}
+
+static lcb_error_t
+do_store3(lcb_t instance, const void *cookie,
+    const lcb_CMDBASE *cmd, int is_durstore)
+{
+    mc_PIPELINE *pipeline;
+    mc_PACKET *packet;
+    mc_REQDATA *rdata;
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    int hsize;
+    int should_compress = 0;
+    lcb_error_t err;
+
+    lcb_storage_t operation;
+    lcb_U32 flags;
+    const lcb_VALBUF *vbuf;
+    lcb_datatype_t datatype;
+
+    protocol_binary_request_set scmd;
+    protocol_binary_request_header *hdr = &scmd.message.header;
+
+    if (!is_durstore) {
+        const lcb_CMDSTORE *simple_cmd = (const lcb_CMDSTORE *)cmd;
+        operation = simple_cmd->operation;
+        flags = simple_cmd->flags;
+        vbuf = &simple_cmd->value;
+        datatype = simple_cmd->datatype;
+    } else {
+        const lcb_CMDSTOREDUR *durcmd = (const lcb_CMDSTOREDUR *)cmd;
+        operation = durcmd->operation;
+        flags = durcmd->flags;
+        vbuf = &durcmd->value;
+        datatype = durcmd->datatype;
+    }
+
+    if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
+        return LCB_EMPTY_KEY;
+    }
+
+    err = get_esize_and_opcode(
+        operation, &hdr->request.opcode, &hdr->request.extlen);
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    switch (operation) {
+    case LCB_APPEND:
+    case LCB_PREPEND:
+        if (cmd->exptime || flags) {
+            return LCB_OPTIONS_CONFLICT;
+        }
+        break;
+    case LCB_ADD:
+        if (cmd->cas) {
+            return LCB_OPTIONS_CONFLICT;
+        }
+        break;
+    default:
+        break;
+    }
+
+    hsize = hdr->request.extlen + sizeof(*hdr);
+
+    err = mcreq_basic_packet(cq, (const lcb_CMDBASE *)cmd, hdr,
+        hdr->request.extlen, &packet, &pipeline, MCREQ_BASICPACKET_F_FALLBACKOK);
+
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    should_compress = can_compress(instance, pipeline, vbuf, datatype);
+    if (should_compress) {
+        int rv = mcreq_compress_value(pipeline, packet, &vbuf->u_buf.contig);
+        if (rv != 0) {
+            mcreq_release_packet(pipeline, packet);
+            return LCB_CLIENT_ENOMEM;
+        }
+    } else {
+        mcreq_reserve_value(pipeline, packet, vbuf);
+    }
+
+    if (is_durstore) {
+        int duropts = 0;
+        lcb_U16 persist_u , replicate_u;
+        const lcb_CMDSTOREDUR *dcmd = (const lcb_CMDSTOREDUR *)cmd;
+        DURSTORECTX *dctx = calloc(1, sizeof(*dctx));
+
+        persist_u = dcmd->persist_to;
+        replicate_u = dcmd->replicate_to;
+        if (dcmd->replicate_to == -1 || dcmd->persist_to == -1) {
+            duropts = LCB_DURABILITY_VALIDATE_CAPMAX;
+        }
+
+        err = lcb_durability_validate(instance, &persist_u, &replicate_u, duropts);
+        if (err != LCB_SUCCESS) {
+            mcreq_wipe_packet(pipeline, packet);
+            mcreq_release_packet(pipeline, packet);
+            free(dctx);
+            return err;
+        }
+
+        dctx->instance = instance;
+        dctx->persist_to = persist_u;
+        dctx->replicate_to = replicate_u;
+        packet->u_rdata.exdata = &dctx->base;
+        packet->flags |= MCREQ_F_REQEXT;
+
+        dctx->base.cookie = cookie;
+        dctx->base.procs = &storedur_procs;
+    }
+
+    rdata = MCREQ_PKT_RDATA(packet);
+    rdata->cookie = cookie;
+    rdata->start = gethrtime();
+
+    scmd.message.body.expiration = htonl(cmd->exptime);
+    scmd.message.body.flags = htonl(flags);
+    hdr->request.magic = PROTOCOL_BINARY_REQ;
+    hdr->request.cas = lcb_htonll(cmd->cas);
+    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+
+    if (should_compress || (datatype & LCB_VALUE_F_SNAPPYCOMP)) {
+        hdr->request.datatype |= PROTOCOL_BINARY_DATATYPE_COMPRESSED;
+    }
+    if (datatype & LCB_VALUE_F_JSON) {
+        hdr->request.datatype |= PROTOCOL_BINARY_DATATYPE_JSON;
+    }
+
+    hdr->request.opaque = packet->opaque;
+    hdr->request.bodylen = htonl(
+            hdr->request.extlen + ntohs(hdr->request.keylen)
+            + get_value_size(packet));
+
+    memcpy(SPAN_BUFFER(&packet->kh_span), scmd.bytes, hsize);
+    LCB_SCHED_ADD(instance, pipeline, packet);
+    TRACE_STORE_BEGIN(hdr, (lcb_CMDSTORE* )cmd);
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_store3(lcb_t instance, const void *cookie, const lcb_CMDSTORE *cmd)
+{
+    return do_store3(instance, cookie, (const lcb_CMDBASE*)cmd, 0);
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_storedur3(lcb_t instance, const void *cookie, const lcb_CMDSTOREDUR *cmd)
+{
+    return do_store3(instance, cookie, (const lcb_CMDBASE*)cmd, 1);
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_store(lcb_t instance, const void *cookie, lcb_size_t num,
+          const lcb_store_cmd_t * const * items)
+{
+    unsigned ii;
+    lcb_error_t err = LCB_SUCCESS;
+
+    lcb_sched_enter(instance);
+    for (ii = 0; ii < num; ii++) {
+        const lcb_store_cmd_t *src = items[ii];
+        lcb_CMDSTORE dst;
+        memset(&dst, 0, sizeof(dst));
+
+        dst.key.contig.bytes = src->v.v0.key;
+        dst.key.contig.nbytes = src->v.v0.nkey;
+        dst._hashkey.contig.bytes = src->v.v0.hashkey;
+        dst._hashkey.contig.nbytes = src->v.v0.nhashkey;
+        dst.value.u_buf.contig.bytes = src->v.v0.bytes;
+        dst.value.u_buf.contig.nbytes = src->v.v0.nbytes;
+        dst.operation = src->v.v0.operation;
+        dst.flags = src->v.v0.flags;
+        dst.datatype = src->v.v0.datatype;
+        dst.cas = src->v.v0.cas;
+        dst.exptime = src->v.v0.exptime;
+        err = lcb_store3(instance, cookie, &dst);
+        if (err != LCB_SUCCESS) {
+            lcb_sched_fail(instance);
+            return err;
+        }
+    }
+    lcb_sched_leave(instance);
+    SYNCMODE_INTERCEPT(instance)
+}

data/ext/libcouchbase/src/operations/subdoc.cc

@@ -0,0 +1,510 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+#include "internal.h"
+#include <vector>
+#include <string>
+#include <include/libcouchbase/subdoc.h>
+
+static lcb_size_t
+get_value_size(mc_PACKET *packet)
+{
+    if (packet->flags & MCREQ_F_HASVALUE) {
+        if (packet->flags & MCREQ_F_VALUE_IOV) {
+            return packet->u_value.multi.total_length;
+        } else {
+            return packet->u_value.single.size;
+        }
+    } else {
+        return 0;
+    }
+}
+
+namespace SubdocCmdTraits {
+enum Options {
+    EMPTY_PATH = 1<<0,
+    ALLOW_EXPIRY = 1<<1,
+    HAS_VALUE = 1<<2,
+    ALLOW_MKDIRP = 1<<3,
+    IS_LOOKUP = 1<<4
+};
+
+struct Traits {
+    const unsigned allow_empty_path;
+    const unsigned allow_expiry;
+    const unsigned has_value;
+    const unsigned allow_mkdir_p;
+    const unsigned is_lookup;
+    const uint8_t opcode;
+
+    inline bool valid() const {
+        return opcode != 0;
+    }
+
+    inline unsigned mode() const {
+        return is_lookup ? LCB_SDMULTI_MODE_LOOKUP : LCB_SDMULTI_MODE_MUTATE;
+    }
+
+    inline Traits(uint8_t op, unsigned options) :
+        allow_empty_path(options & EMPTY_PATH),
+        allow_expiry(options & ALLOW_EXPIRY),
+        has_value(options & HAS_VALUE),
+        allow_mkdir_p(options & ALLOW_MKDIRP),
+        is_lookup(options & IS_LOOKUP),
+        opcode(op) {}
+};
+
+static const Traits
+Get(PROTOCOL_BINARY_CMD_SUBDOC_GET, IS_LOOKUP);
+
+static const Traits
+Exists(PROTOCOL_BINARY_CMD_SUBDOC_EXISTS, IS_LOOKUP);
+
+static const Traits
+GetCount(PROTOCOL_BINARY_CMD_SUBDOC_GET_COUNT, IS_LOOKUP|EMPTY_PATH);
+
+static const Traits
+DictAdd(PROTOCOL_BINARY_CMD_SUBDOC_DICT_ADD, ALLOW_EXPIRY|HAS_VALUE);
+
+static const Traits
+DictUpsert(PROTOCOL_BINARY_CMD_SUBDOC_DICT_UPSERT,
+    ALLOW_EXPIRY|HAS_VALUE|ALLOW_MKDIRP);
+
+static const Traits
+Remove(PROTOCOL_BINARY_CMD_SUBDOC_DELETE, ALLOW_EXPIRY);
+
+static const Traits
+ArrayInsert(PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_INSERT,
+    ALLOW_EXPIRY|HAS_VALUE);
+
+static const Traits
+Replace(PROTOCOL_BINARY_CMD_SUBDOC_REPLACE, ALLOW_EXPIRY|HAS_VALUE);
+
+static const Traits
+ArrayAddFirst(PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_PUSH_FIRST,
+    ALLOW_EXPIRY|HAS_VALUE|EMPTY_PATH|ALLOW_MKDIRP);
+
+static const Traits
+ArrayAddLast(PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_PUSH_LAST,
+    ALLOW_EXPIRY|HAS_VALUE|EMPTY_PATH|ALLOW_MKDIRP);
+
+static const Traits
+ArrayAddUnique(PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_ADD_UNIQUE,
+    ALLOW_EXPIRY|HAS_VALUE|EMPTY_PATH|ALLOW_MKDIRP);
+
+static const Traits
+Counter(PROTOCOL_BINARY_CMD_SUBDOC_COUNTER, ALLOW_EXPIRY|HAS_VALUE|ALLOW_MKDIRP);
+
+static const Traits
+Invalid(0, 0);
+
+const Traits&
+find(unsigned mode)
+{
+    switch (mode) {
+    case LCB_SDCMD_REPLACE:
+        return Replace;
+    case LCB_SDCMD_DICT_ADD:
+        return DictAdd;
+    case LCB_SDCMD_DICT_UPSERT:
+        return DictUpsert;
+    case LCB_SDCMD_ARRAY_ADD_FIRST:
+        return ArrayAddFirst;
+    case LCB_SDCMD_ARRAY_ADD_LAST:
+        return ArrayAddLast;
+    case LCB_SDCMD_ARRAY_ADD_UNIQUE:
+        return ArrayAddUnique;
+    case LCB_SDCMD_ARRAY_INSERT:
+        return ArrayInsert;
+    case LCB_SDCMD_GET:
+        return Get;
+    case LCB_SDCMD_EXISTS:
+        return Exists;
+    case LCB_SDCMD_GET_COUNT:
+        return GetCount;
+    case LCB_SDCMD_REMOVE:
+        return Remove;
+    case LCB_SDCMD_COUNTER:
+        return Counter;
+    default:
+        return Invalid;
+    }
+}
+}
+
+static size_t
+get_valbuf_size(const lcb_VALBUF& vb)
+{
+    if (vb.vtype == LCB_KV_COPY || vb.vtype == LCB_KV_CONTIG) {
+        return vb.u_buf.contig.nbytes;
+    } else {
+        if (vb.u_buf.multi.total_length) {
+            return vb.u_buf.multi.total_length;
+        } else {
+            size_t tmp = 0;
+            for (size_t ii = 0; ii < vb.u_buf.multi.niov; ++ii) {
+                tmp += vb.u_buf.multi.iov[ii].iov_len;
+            }
+            return tmp;
+        }
+    }
+}
+
+struct MultiBuilder {
+    MultiBuilder(const lcb_CMDSUBDOC *cmd_)
+    : cmd(cmd_), payload_size(0), mode(0) {
+        size_t ebufsz = is_lookup() ? cmd->nspecs * 4 : cmd->nspecs * 8;
+        extra_body = new char[ebufsz];
+        bodysz = 0;
+    }
+
+    ~MultiBuilder() {
+        if (extra_body != NULL) {
+            delete[] extra_body;
+        }
+    }
+
+    inline MultiBuilder(const MultiBuilder&);
+
+    // IOVs which are fed into lcb_VALBUF for subsequent use
+    const lcb_CMDSUBDOC *cmd;
+    std::vector<lcb_IOV> iovs;
+    char *extra_body;
+    size_t bodysz;
+
+    // Total size of the payload itself
+    size_t payload_size;
+
+    unsigned mode;
+
+    bool is_lookup() const {
+        return mode == LCB_SDMULTI_MODE_LOOKUP;
+    }
+
+    bool is_mutate() const {
+        return mode == LCB_SDMULTI_MODE_MUTATE;
+    }
+
+    void maybe_setmode(const SubdocCmdTraits::Traits& t) {
+        if (mode == 0) {
+            mode = t.mode();
+        }
+    }
+
+    template <typename T> void add_field(T itm, size_t len) {
+        const char *b = reinterpret_cast<const char *>(&itm);
+        memcpy(extra_body + bodysz, b, len);
+        bodysz += len;
+    }
+
+    const char *extra_mark() const {
+        return extra_body + bodysz;
+    }
+
+    void add_extras_iov(const char *last_begin) {
+        const char *p_end = extra_mark();
+        add_iov(last_begin, p_end - last_begin);
+    }
+
+    void add_iov(const void *b, size_t n) {
+        if (!n) {
+            return;
+        }
+
+        lcb_IOV iov;
+        iov.iov_base = const_cast<void*>(b);
+        iov.iov_len = n;
+        iovs.push_back(iov);
+        payload_size += n;
+    }
+
+    void add_iov(const lcb_VALBUF& vb) {
+        if (vb.vtype == LCB_KV_CONTIG || vb.vtype == LCB_KV_COPY) {
+            add_iov(vb.u_buf.contig.bytes, vb.u_buf.contig.nbytes);
+        } else {
+            for (size_t ii = 0; ii < vb.u_buf.contig.nbytes; ++ii) {
+                const lcb_IOV& iov = vb.u_buf.multi.iov[ii];
+                if (!iov.iov_len) {
+                    continue; // Skip it
+                }
+                payload_size += iov.iov_len;
+                iovs.push_back(iov);
+            }
+        }
+    }
+
+    inline lcb_error_t add_spec(const lcb_SDSPEC *);
+};
+
+lcb_error_t
+MultiBuilder::add_spec(const lcb_SDSPEC *spec)
+{
+    const SubdocCmdTraits::Traits& trait = SubdocCmdTraits::find(spec->sdcmd);
+    if (!trait.valid()) {
+        return LCB_UNKNOWN_SDCMD;
+    }
+    maybe_setmode(trait);
+
+    if (trait.mode() != mode) {
+        return LCB_OPTIONS_CONFLICT;
+    }
+
+    const char *p_begin = extra_mark();
+    // opcode
+    add_field(trait.opcode, 1);
+    // flags
+    uint8_t sdflags = 0;
+    if (spec->options & LCB_SDSPEC_F_MKINTERMEDIATES) {
+        sdflags = SUBDOC_FLAG_MKDIR_P;
+    }
+    if (spec->options & LCB_SDSPEC_F_MKDOCUMENT) {
+        sdflags |= SUBDOC_FLAG_MKDOC;
+    }
+    add_field(sdflags, 1);
+
+    uint16_t npath = static_cast<uint16_t>(spec->path.contig.nbytes);
+    if (!npath && !trait.allow_empty_path) {
+        return LCB_EMPTY_PATH;
+    }
+
+    // Path length
+    add_field(static_cast<uint16_t>(htons(npath)), 2);
+
+    uint32_t vsize = 0;
+    if (is_mutate()) {
+        // Mutation needs an additional 'value' spec.
+        vsize = get_valbuf_size(spec->value);
+        add_field(static_cast<uint32_t>(htonl(vsize)), 4);
+    }
+
+    // Finalize the header..
+    add_extras_iov(p_begin);
+
+    // Add the actual path
+    add_iov(spec->path.contig.bytes, spec->path.contig.nbytes);
+    if (vsize) {
+        add_iov(spec->value);
+    }
+    return LCB_SUCCESS;
+}
+
+
+static lcb_error_t
+sd3_single(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
+{
+    // Find the trait
+    const lcb_SDSPEC *spec = cmd->specs;
+    const SubdocCmdTraits::Traits& traits = SubdocCmdTraits::find(spec->sdcmd);
+    lcb_error_t rc;
+
+    // Any error here is implicitly related to the only spec
+    if (cmd->error_index) {
+        *cmd->error_index = 0;
+    }
+
+    if (!traits.valid()) {
+        return LCB_UNKNOWN_SDCMD;
+    }
+
+    // Determine if the trait matches the mode. Technically we don't care
+    // about this (since it's always a single command) but we do want the
+    // API to remain consistent.
+    if (cmd->multimode != 0 && cmd->multimode != traits.mode()) {
+        return LCB_OPTIONS_CONFLICT;
+    }
+
+    if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
+        return LCB_EMPTY_KEY;
+    }
+    if (LCB_KEYBUF_IS_EMPTY(&spec->path) && !traits.allow_empty_path) {
+        return LCB_EMPTY_PATH;
+    }
+
+    lcb_VALBUF valbuf;
+    const lcb_VALBUF *valbuf_p = &valbuf;
+    lcb_IOV tmpiov[2];
+    lcb_FRAGBUF *fbuf = &valbuf.u_buf.multi;
+
+    valbuf.vtype = LCB_KV_IOVCOPY;
+    fbuf->iov = tmpiov;
+    fbuf->niov = 1;
+    fbuf->total_length = 0;
+    tmpiov[0].iov_base = const_cast<void*>(spec->path.contig.bytes);
+    tmpiov[0].iov_len = spec->path.contig.nbytes;
+
+    if (traits.has_value) {
+        if (spec->value.vtype == LCB_KV_COPY) {
+            fbuf->niov = 2;
+            /* Subdoc value is the second IOV */
+            tmpiov[1].iov_base = (void *)spec->value.u_buf.contig.bytes;
+            tmpiov[1].iov_len = spec->value.u_buf.contig.nbytes;
+        } else {
+            /* Assume properly formatted packet */
+            valbuf_p = &spec->value;
+        }
+    }
+
+    uint8_t extlen = 3;
+    uint32_t exptime = 0;
+    if (cmd->exptime) {
+        if (!traits.allow_expiry) {
+            return LCB_OPTIONS_CONFLICT;
+        }
+        exptime = cmd->exptime;
+        extlen = 7;
+    }
+
+    protocol_binary_request_subdocument request;
+    protocol_binary_request_header *hdr = &request.message.header;
+    mc_PACKET *packet;
+    mc_PIPELINE *pipeline;
+
+    rc = mcreq_basic_packet(&instance->cmdq,
+        (const lcb_CMDBASE*)cmd,
+        hdr, extlen, &packet, &pipeline, MCREQ_BASICPACKET_F_FALLBACKOK);
+
+    if (rc != LCB_SUCCESS) {
+        return rc;
+    }
+
+    rc = mcreq_reserve_value(pipeline, packet, valbuf_p);
+    if (rc != LCB_SUCCESS) {
+        mcreq_wipe_packet(pipeline, packet);
+        mcreq_release_packet(pipeline, packet);
+        return rc;
+    }
+
+    MCREQ_PKT_RDATA(packet)->cookie = cookie;
+    MCREQ_PKT_RDATA(packet)->start = gethrtime();
+
+    hdr->request.magic = PROTOCOL_BINARY_REQ;
+    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr->request.extlen = packet->extlen;
+    hdr->request.opaque = packet->opaque;
+    hdr->request.cas = lcb_htonll(cmd->cas);
+    hdr->request.bodylen = htonl(hdr->request.extlen +
+        ntohs(hdr->request.keylen) + get_value_size(packet));
+
+    request.message.extras.pathlen = htons(spec->path.contig.nbytes);
+    request.message.extras.subdoc_flags = 0;
+
+    if (spec->options & LCB_SDSPEC_F_MKINTERMEDIATES) {
+        request.message.extras.subdoc_flags |= SUBDOC_FLAG_MKDIR_P;
+    }
+    if (spec->options & LCB_SDSPEC_F_MKDOCUMENT) {
+        request.message.extras.subdoc_flags |= SUBDOC_FLAG_MKDOC;
+    }
+
+    hdr->request.opcode = traits.opcode;
+    memcpy(SPAN_BUFFER(&packet->kh_span), request.bytes, sizeof request.bytes);
+    if (exptime) {
+        exptime = htonl(exptime);
+        memcpy(SPAN_BUFFER(&packet->kh_span) + sizeof request.bytes, &exptime, 4);
+    }
+
+    LCB_SCHED_ADD(instance, pipeline, packet);
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_subdoc3(lcb_t instance, const void *cookie, const lcb_CMDSUBDOC *cmd)
+{
+    // First validate the command
+    if (cmd->nspecs == 0) {
+        return LCB_ENO_COMMANDS;
+    }
+
+    if (cmd->nspecs == 1) {
+        return sd3_single(instance, cookie, cmd);
+    }
+
+    uint32_t exp = cmd->exptime;
+    lcb_error_t rc = LCB_SUCCESS;
+
+    MultiBuilder ctx(cmd);
+    if (cmd->error_index) {
+        *cmd->error_index = -1;
+    }
+
+    if (exp && !ctx.is_mutate()) {
+        return LCB_OPTIONS_CONFLICT;
+    }
+
+    for (size_t ii = 0; ii < cmd->nspecs; ++ii) {
+        if (cmd->error_index) {
+            *cmd->error_index = ii;
+        }
+        rc = ctx.add_spec(cmd->specs + ii);
+        if (rc != LCB_SUCCESS) {
+            return rc;
+        }
+    }
+
+    mc_PIPELINE *pl;
+    mc_PACKET *pkt;
+    uint8_t extlen = exp ? 4 : 0;
+    protocol_binary_request_header hdr;
+
+    if (cmd->error_index) {
+        *cmd->error_index = -1;
+    }
+
+    rc = mcreq_basic_packet(
+        &instance->cmdq, reinterpret_cast<const lcb_CMDBASE*>(cmd),
+        &hdr, extlen, &pkt, &pl, MCREQ_BASICPACKET_F_FALLBACKOK);
+
+    if (rc != LCB_SUCCESS) {
+        return rc;
+    }
+
+    lcb_VALBUF vb = { LCB_KV_IOVCOPY };
+    vb.u_buf.multi.iov = &ctx.iovs[0];
+    vb.u_buf.multi.niov = ctx.iovs.size();
+    vb.u_buf.multi.total_length = ctx.payload_size;
+    rc = mcreq_reserve_value(pl, pkt, &vb);
+
+    if (rc != LCB_SUCCESS) {
+        mcreq_wipe_packet(pl, pkt);
+        mcreq_release_packet(pl, pkt);
+        return rc;
+    }
+
+    // Set the header fields.
+    hdr.request.magic = PROTOCOL_BINARY_REQ;
+    if (ctx.is_lookup()) {
+        hdr.request.opcode = PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP;
+    } else {
+        hdr.request.opcode = PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION;
+    }
+    hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr.request.extlen = pkt->extlen;
+    hdr.request.opaque = pkt->opaque;
+    hdr.request.cas = lcb_htonll(cmd->cas);
+    hdr.request.bodylen = htonl(hdr.request.extlen +
+        ntohs(hdr.request.keylen) + ctx.payload_size);
+    memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof hdr.bytes);
+    if (exp) {
+        exp = htonl(exp);
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + 24, &exp, 4);
+    }
+
+    MCREQ_PKT_RDATA(pkt)->cookie = cookie;
+    MCREQ_PKT_RDATA(pkt)->start = gethrtime();
+    LCB_SCHED_ADD(instance, pl, pkt);
+    return LCB_SUCCESS;
+}
+