libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/settings.h

@@ -179,7 +179,8 @@ LCB_INTERNAL_API
 void
 lcb_settings_unref(lcb_settings *);
 
-#define lcb_settings_ref(settings) (settings)->refcount++
+#define lcb_settings_ref(settings) ((void)(settings)->refcount++)
+#define lcb_settings_ref2(settings) ((settings)->refcount++, settings)
 
 #ifdef __cplusplus
 }

data/ext/libcouchbase/src/ssl/ssl_c.c

@@ -137,6 +137,7 @@ async_write(void *arg)
 {
     lcbio_CSSL *cs = arg;
     appdata_encode(cs);
+    schedule_wants(cs);
     appdata_free_flushed(cs);
 }
 

data/ext/libcouchbase/src/ssl/ssl_e.c

@@ -16,7 +16,6 @@
  */
 
 #include "ssl_iot_common.h"
-#include "simplestring.h"
 #include <openssl/err.h>
 /**
  * Event-Style SSL Wrapping.

data/ext/libcouchbase/src/trace.h

@@ -40,33 +40,33 @@
 
 #define TRACE_BEGIN_COMMON(TGT, req, cmd,  ...) \
     TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
-    (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes, ## __VA_ARGS__)
+    (const char *)((cmd)->key.contig.bytes), (cmd)->key.contig.nbytes, ## __VA_ARGS__)
 
 #define TRACE_BEGIN_SIMPLE(TGT, req, cmd) \
     TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
-        (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
+        (const char *)(cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
 
 #define TRACE_END_COMMON(TGT, mcresp, resp, ...) \
-    TGT(PACKET_OPAQUE(mcresp), 0, PACKET_OPCODE(mcresp), (resp)->rc, (const char *)(resp)->key, (resp)->nkey, \
+    TGT(mcresp->opaque(), 0, mcresp->opcode(), (resp)->rc, (const char *)(resp)->key, (resp)->nkey, \
         ## __VA_ARGS__)
 
 #define TRACE_END_SIMPLE(TGT, mcresp, resp) \
-    TGT(PACKET_OPAQUE(mcresp), 0, PACKET_OPCODE(mcresp), (resp)->rc, (const char *)(resp)->key, (resp)->nkey)
+    TGT(mcresp->opaque(), 0, mcresp->opcode(), (resp)->rc, (const char *)(resp)->key, (resp)->nkey)
 
 #define TRACE_GET_BEGIN(req, cmd) \
     TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_GET_BEGIN, req, cmd, (cmd)->exptime))
 
 #define TRACE_GET_END(mcresp, resp) \
     TRACE(TRACE_END_COMMON(LIBCOUCHBASE_GET_END, mcresp, resp, \
-        (char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
-        PACKET_DATATYPE(mcresp)))
+        (const char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
+        mcresp->datatype()))
 
 #define TRACE_UNLOCK_BEGIN(req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_UNLOCK_BEGIN, req, cmd))
 #define TRACE_UNLOCK_END(mcresp, resp) TRACE(TRACE_END_SIMPLE(LIBCOUCHBASE_UNLOCK_END, mcresp, resp))
 
 #define TRACE_STORE_BEGIN(req, cmd) \
     TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_STORE_BEGIN, req, cmd, \
-        ( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
+        (const char *)( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
         ( (cmd)->value.vtype == LCB_KV_IOV ? 0 : (cmd)->value.u_buf.contig.nbytes ),\
         (cmd)->flags, (cmd)->cas, (req)->request.datatype, (cmd)->exptime))
 
@@ -98,7 +98,7 @@
         (resp)->cas, (resp)->status, (resp)->ismaster, (resp)->ttp, (resp)->ttr))
 
 #define TRACE_OBSERVE_END(mcresp) \
-    TRACE(LIBCOUCHBASE_OBSERVE_END(PACKET_OPAQUE(mcresp), 0, PACKET_OPCODE(mcresp), LCB_SUCCESS))
+    TRACE(LIBCOUCHBASE_OBSERVE_END(mcresp->opaque(), 0, mcresp->opcode(), LCB_SUCCESS))
 
 #define TRACE_HTTP_BEGIN(req) TRACE(LIBCOUCHBASE_HTTP_BEGIN((req)->url, (req)->nurl, (req)->method))
 #define TRACE_HTTP_END(req, rc, resp) TRACE(LIBCOUCHBASE_HTTP_END((req)->url, (req)->nurl, (req)->method, (resp)->rc, (resp)->htstatus

data/ext/libcouchbase/src/vbucket/vbucket.c

@@ -26,7 +26,6 @@
 #include "json-inl.h"
 #include "hash.h"
 #include "crc32.h"
-#include "simplestring.h"
 
 #define STRINGIFY_(X) #X
 #define STRINGIFY(X) STRINGIFY_(X)

data/ext/libcouchbase/src/views/{docreq.c → docreq.cc}

@@ -2,56 +2,53 @@
 #include "internal.h"
 #include "sllist-inl.h"
 
+using namespace lcb::docreq;
+
 static void docreq_handler(void *arg);
-static void invoke_pending(lcb_DOCQUEUE*);
+static void invoke_pending(Queue*);
 static void doc_callback(lcb_t,int, const lcb_RESPBASE *);
 
 #define MAX_PENDING_DOCREQ 10
 #define MIN_SCHED_SIZE 5
 #define DOCQ_DELAY_US 200000
 
-#define DOCQ_REF(q) (q)->refcount++
-#define DOCQ_UNREF(q) if (!--(q)->refcount) { docq_free(q); }
-
-lcb_DOCQUEUE *
-lcbdocq_create(lcb_t instance)
-{
-    lcb_DOCQUEUE *q = calloc(1, sizeof *q);
-    q->timer = lcbio_timer_new(instance->iotable, q, docreq_handler);
-    q->refcount = 1;
-    q->instance = instance;
-    q->max_pending_response = MAX_PENDING_DOCREQ;
-    q->min_batch_size = MIN_SCHED_SIZE;
-    return q;
+Queue::Queue(lcb_t instance_)
+    : instance(instance_),
+      parent(NULL),
+      timer(lcbio_timer_new(instance->iotable, this, docreq_handler)),
+      cb_ready(NULL), cb_throttle(NULL),
+      n_awaiting_schedule(0),
+      n_awaiting_response(0),
+      max_pending_response(MAX_PENDING_DOCREQ),
+      min_batch_size(MIN_SCHED_SIZE),
+      cancelled(false),
+      refcount(1)
+      {
+
+    memset(&pending_gets, 0, sizeof pending_gets);
+    memset(&cb_queue, 0, sizeof cb_queue);
 }
 
-static void
-docq_free(lcb_DOCQUEUE *q)
-{
-    lcbdocq_cancel(q);
-    lcbio_timer_destroy(q->timer);
-    free(q);
+Queue::~Queue() {
+    cancel();
+    lcbio_timer_destroy(timer);
 }
 
-void
-lcbdocq_unref(lcb_DOCQUEUE *q)
-{
-    DOCQ_UNREF(q);
+void Queue::unref() {
+    if (!--refcount) {
+        delete this;
+    }
 }
 
-void
-lcbdocq_cancel(lcb_DOCQUEUE *q)
-{
-    if (!q->cancelled) {
-        q->cancelled = 1;
-    }
+void Queue::cancel() {
+    cancelled = true;
 }
 
 /* Calling this function ensures that the request will be scheduled in due
  * time. This may be done at the next event loop iteration, or after a delay
  * depending on how many items are actually found within the queue. */
 static void
-docq_poke(lcb_DOCQUEUE *q)
+docq_poke(Queue *q)
 {
     if (q->n_awaiting_response < q->max_pending_response) {
         if (q->n_awaiting_schedule > q->min_batch_size) {
@@ -65,27 +62,26 @@ docq_poke(lcb_DOCQUEUE *q)
     }
 }
 
-void
-lcbdocq_add(lcb_DOCQUEUE *q, lcb_DOCQREQ *req)
+void Queue::add(DocRequest *req)
 {
-    sllist_append(&q->pending_gets, &req->slnode);
-    q->n_awaiting_schedule++;
-    req->parent = q;
+    sllist_append(&pending_gets, &req->slnode);
+    n_awaiting_schedule++;
+    req->parent = this;
     req->ready = 0;
-    DOCQ_REF(q);
-    docq_poke(q);
+    ref();
+    docq_poke(this);
 }
 
 static void
 docreq_handler(void *arg)
 {
-    lcb_DOCQUEUE *q = arg;
+    Queue *q = reinterpret_cast<Queue*>(arg);
     sllist_iterator iter;
     lcb_t instance = q->instance;
 
     lcb_sched_enter(instance);
     SLLIST_ITERFOR(&q->pending_gets, &iter) {
-        lcb_DOCQREQ *cont = SLLIST_ITEM(iter.cur, lcb_DOCQREQ, slnode);
+        DocRequest *cont = SLLIST_ITEM(iter.cur, DocRequest, slnode);
 
         if (q->n_awaiting_response > q->max_pending_response) {
             lcbio_timer_rearm(q->timer, DOCQ_DELAY_US);
@@ -136,13 +132,12 @@ docreq_handler(void *arg)
 /* Invokes the callback on all requests which are ready, until a request which
  * is not yet ready is reached. */
 static void
-invoke_pending(lcb_DOCQUEUE *q)
+invoke_pending(Queue *q)
 {
     sllist_iterator iter = { NULL };
-
-    DOCQ_REF(q);
+    q->ref();
     SLLIST_ITERFOR(&q->cb_queue, &iter) {
-        lcb_DOCQREQ *dreq = SLLIST_ITEM(iter.cur, lcb_DOCQREQ, slnode);
+        DocRequest *dreq = SLLIST_ITEM(iter.cur, DocRequest, slnode);
         void *bufh = NULL;
 
         if (dreq->ready == 0) {
@@ -157,21 +152,21 @@ invoke_pending(lcb_DOCQUEUE *q)
 
         q->cb_ready(q, dreq);
         if (bufh) {
-            lcb_backbuf_unref(bufh);
+            lcb_backbuf_unref(reinterpret_cast<lcb_BACKBUF>(bufh));
         }
-        DOCQ_UNREF(q);
+        q->unref();
     }
-    DOCQ_UNREF(q);
+    q->unref();
 }
 
 static void
-doc_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+doc_callback(lcb_t, int, const lcb_RESPBASE *rb)
 {
     const lcb_RESPGET *rg = (const lcb_RESPGET *)rb;
-    lcb_DOCQREQ *dreq = rb->cookie;
-    lcb_DOCQUEUE *q = dreq->parent;
+    DocRequest *dreq = reinterpret_cast<DocRequest*>(rb->cookie);
+    Queue *q = dreq->parent;
 
-    DOCQ_REF(q);
+    q->ref();
 
     q->n_awaiting_response--;
     dreq->docresp = *rg;
@@ -182,13 +177,12 @@ doc_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
     /* Reference the response data, since we might not be invoking this right
      * away */
     if (rg->rc == LCB_SUCCESS) {
-        lcb_backbuf_ref(dreq->docresp.bufh);
+        lcb_backbuf_ref(reinterpret_cast<lcb_BACKBUF>(dreq->docresp.bufh));
     }
 
     /* Ensure the invoke_pending doesn't destroy us */
     invoke_pending(q);
     docq_poke(q);
 
-    DOCQ_UNREF(q);
-    (void)instance; (void)cbtype;
+    q->unref();
 }

data/ext/libcouchbase/src/views/docreq.h

@@ -10,14 +10,23 @@
 #include <lcbio/lcbio.h>
 #include "sllist.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct lcb_DOCQUEUE_st;
-struct lcb_DOCREQ_st;
+namespace lcb {
+namespace docreq {
+
+struct Queue;
+struct DocRequest;
+
+struct Queue {
+    Queue(lcb_t);
+    ~Queue();
+    void add(DocRequest*);
+    void unref();
+    void ref() {refcount++;}
+    void cancel();
+    bool has_pending() const {
+        return n_awaiting_response || n_awaiting_schedule;
+    }
 
-typedef struct lcb_DOCQUEUE_st{
     lcb_t instance;
     void *parent;
     lcbio_pTIMER timer;
@@ -25,13 +34,13 @@ typedef struct lcb_DOCQUEUE_st{
     /**Called when a document is ready
      * @param The queue
      * @param The document */
-    void (*cb_ready)(struct lcb_DOCQUEUE_st*,struct lcb_DOCREQ_st*);
+    void (*cb_ready)(struct Queue*,struct DocRequest*);
 
     /**Called when throttle state changes. This may be used by higher layers
      * for appropriate flow control
      * @param The queue
      * @param enabled Whether throttling has been enabled or disabled */
-    void (*cb_throttle)(struct lcb_DOCQUEUE_st*, int enabled);
+    void (*cb_throttle)(struct Queue*, int enabled);
 
     /**This queue holds requests which were not yet issued to the library
      * via lcb_get3(). This list is aggregated after each chunk callback and
@@ -49,35 +58,20 @@ typedef struct lcb_DOCQUEUE_st{
     unsigned min_batch_size;
     unsigned cancelled;
     unsigned refcount;
-} lcb_DOCQUEUE;
+};
 
-typedef struct lcb_DOCREQ_st {
+struct DocRequest {
     /* Callback. Must be first */
     lcb_RESPCALLBACK callback;
     sllist_node slnode;
-    lcb_DOCQUEUE *parent;
+    Queue *parent;
     lcb_RESPGET docresp;
     /* To be filled in by the subclass */
     lcb_IOV docid;
     unsigned ready;
-} lcb_DOCQREQ;
-
-lcb_DOCQUEUE *
-lcbdocq_create(lcb_t instance);
-
-void
-lcbdocq_add(lcb_DOCQUEUE *q, lcb_DOCQREQ *req);
+};
 
-void
-lcbdocq_unref(lcb_DOCQUEUE *);
 
-void
-lcbdocq_cancel(lcb_DOCQUEUE *q);
-
-#define lcbdocq_has_pending(q) \
-    ((q)->n_awaiting_response || (q)->n_awaiting_schedule)
-
-#ifdef __cplusplus
-}
-#endif
+} // namespace docreq
+} // namespace lcb
 #endif

data/ext/libcouchbase/src/views/viewreq.cc

@@ -0,0 +1,318 @@
+#include "viewreq.h"
+#include "sllist-inl.h"
+#include "http/http.h"
+#include "internal.h"
+
+#define MAX_GET_URI_LENGTH 2048
+using namespace lcb::views;
+
+static void chunk_callback(lcb_t, int, const lcb_RESPBASE*);
+
+template <typename value_type, typename size_type>
+void IOV2PTRLEN(const lcb_IOV* iov, value_type*& ptr, size_type& len) {
+    ptr = reinterpret_cast<const value_type*>(iov->iov_base);
+    len = iov->iov_len;
+}
+
+/* Whether the request (from the user side) is still ongoing */
+#define CAN_CONTINUE(req) ((req)->callback != NULL)
+#define LOGARGS(instance, lvl) instance->settings, "views", LCB_LOG_##lvl, __FILE__, __LINE__
+
+void ViewRequest::invoke_last(lcb_error_t err) {
+    lcb_RESPVIEWQUERY resp = { 0 };
+    if (callback == NULL) {
+        return;
+    }
+    if (docq && docq->has_pending()) {
+        return;
+    }
+
+    resp.rc = err;
+    resp.htresp = cur_htresp;
+    resp.cookie = const_cast<void*>(cookie);
+    resp.rflags = LCB_RESP_F_FINAL;
+    if (parser && parser->meta_complete) {
+        resp.value = parser->meta_buf.c_str();
+        resp.nvalue = parser->meta_buf.size();
+    } else {
+        resp.rflags |= LCB_RESP_F_CLIENTGEN;
+    }
+    callback(instance, LCB_CALLBACK_VIEWQUERY, &resp);
+    cancel();
+}
+
+void ViewRequest::invoke_row(lcb_RESPVIEWQUERY *resp) {
+    if (callback == NULL) {
+        return;
+    }
+    resp->htresp = cur_htresp;
+    resp->cookie = const_cast<void*>(cookie);
+    callback(instance, LCB_CALLBACK_VIEWQUERY, resp);
+}
+
+static void
+chunk_callback(lcb_t instance, int, const lcb_RESPBASE *rb)
+{
+    const lcb_RESPHTTP *rh = (const lcb_RESPHTTP *)rb;
+    ViewRequest *req = reinterpret_cast<ViewRequest*>(rh->cookie);
+
+    req->cur_htresp = rh;
+
+    if (rh->rc != LCB_SUCCESS || rh->htstatus != 200 || (rh->rflags & LCB_RESP_F_FINAL)) {
+        if (req->lasterr == LCB_SUCCESS && rh->htstatus != 200) {
+            if (rh->rc != LCB_SUCCESS) {
+                req->lasterr = rh->rc;
+            } else {
+                lcb_log(LOGARGS(instance, DEBUG), "Got not ok http status %d", rh->htstatus);
+                req->lasterr = LCB_HTTP_ERROR;
+            }
+        }
+        req->ref();
+        req->invoke_last();
+        if (rh->rflags & LCB_RESP_F_FINAL) {
+            req->htreq = NULL;
+            req->unref();
+        }
+        req->cur_htresp = NULL;
+        req->unref();
+        return;
+    }
+
+    if (!CAN_CONTINUE(req)) {
+        return;
+    }
+
+    req->refcount++;
+    req->parser->feed(reinterpret_cast<const char*>(rh->body), rh->nbody);
+    req->cur_htresp = NULL;
+    req->unref();
+}
+
+static void
+do_copy_iov(std::string& dstbuf, lcb_IOV *dstiov, const lcb_IOV *srciov)
+{
+    dstiov->iov_len = srciov->iov_len;
+    dstiov->iov_base = const_cast<char*>(dstbuf.c_str() + dstbuf.size());
+    dstbuf.append(reinterpret_cast<const char*>(srciov->iov_base), srciov->iov_len);
+}
+
+static VRDocRequest *
+mk_docreq(const lcb::jsparse::Row *datum)
+{
+    size_t extra_alloc = 0;
+    VRDocRequest *dreq;
+    extra_alloc =
+            datum->key.iov_len + datum->value.iov_len +
+            datum->geo.iov_len + datum->docid.iov_len;
+
+    dreq = new VRDocRequest();
+    dreq->rowbuf.reserve(extra_alloc);
+    do_copy_iov(dreq->rowbuf, &dreq->key, &datum->key);
+    do_copy_iov(dreq->rowbuf, &dreq->value, &datum->value);
+    do_copy_iov(dreq->rowbuf, &dreq->docid, &datum->docid);
+    do_copy_iov(dreq->rowbuf, &dreq->geo, &datum->geo);
+    return dreq;
+}
+
+void ViewRequest::JSPARSE_on_row(const lcb::jsparse::Row& datum) {
+    using lcb::jsparse::Row;
+    if (!is_no_rowparse()) {
+        parser->parse_viewrow(const_cast<Row&>(datum));
+    }
+
+    if (is_include_docs() && datum.docid.iov_len && callback) {
+        VRDocRequest *dreq = mk_docreq(&datum);
+        dreq->parent = this;
+        docq->add(dreq);
+        ref();
+
+    } else {
+        lcb_RESPVIEWQUERY resp = { 0 };
+        if (is_no_rowparse()) {
+            IOV2PTRLEN(&datum.row, resp.value, resp.nvalue);
+        } else {
+            IOV2PTRLEN(&datum.key, resp.key, resp.nkey);
+            IOV2PTRLEN(&datum.docid, resp.docid, resp.ndocid);
+            IOV2PTRLEN(&datum.value, resp.value, resp.nvalue);
+            IOV2PTRLEN(&datum.geo, resp.geometry, resp.ngeometry);
+        }
+        resp.htresp = cur_htresp;
+        invoke_row(&resp);
+    }
+}
+
+void ViewRequest::JSPARSE_on_error(const std::string&) {
+    invoke_last(LCB_PROTOCOL_ERROR);
+}
+
+void ViewRequest::JSPARSE_on_complete(const std::string&) {
+    // Nothing
+}
+
+static void
+cb_doc_ready(lcb::docreq::Queue *q, lcb::docreq::DocRequest *req_base)
+{
+    lcb_RESPVIEWQUERY resp = { 0 };
+    VRDocRequest *dreq = (VRDocRequest*)req_base;
+    resp.docresp = &dreq->docresp;
+    IOV2PTRLEN(&dreq->key, resp.key, resp.nkey);
+    IOV2PTRLEN(&dreq->value, resp.value, resp.nvalue);
+    IOV2PTRLEN(&dreq->docid, resp.docid, resp.ndocid);
+    IOV2PTRLEN(&dreq->geo, resp.geometry, resp.ngeometry);
+
+    if (q->parent) {
+        reinterpret_cast<ViewRequest*>(q->parent)->invoke_row(&resp);
+    }
+
+    delete dreq;
+
+    if (q->parent) {
+        reinterpret_cast<ViewRequest*>(q->parent)->unref();
+    }
+}
+
+static void
+cb_docq_throttle(lcb::docreq::Queue *q, int enabled)
+{
+    ViewRequest *req = reinterpret_cast<ViewRequest*>(q->parent);
+    if (req == NULL || req->htreq == NULL) {
+        return;
+    }
+    if (enabled) {
+        req->htreq->pause();
+    } else {
+        req->htreq->resume();
+    }
+}
+
+ViewRequest::~ViewRequest() {
+    invoke_last();
+
+    if (parser != NULL) {
+        delete parser;
+    }
+    if (htreq != NULL) {
+        lcb_cancel_http_request(instance, htreq);
+    }
+    if (docq != NULL) {
+        docq->parent = NULL;
+        docq->unref();
+    }
+}
+
+lcb_error_t ViewRequest::request_http(const lcb_CMDVIEWQUERY *cmd) {
+    lcb_CMDHTTP htcmd = { 0 };
+    htcmd.method = LCB_HTTP_METHOD_GET;
+    htcmd.type = LCB_HTTP_TYPE_VIEW;
+    htcmd.cmdflags = LCB_CMDHTTP_F_STREAM;
+
+    std::string path;
+    path.append("_design/");
+    path.append(cmd->ddoc, cmd->nddoc);
+    path.append(is_spatial() ? "/_spatial/" : "/_view/");
+    path.append(cmd->view, cmd->nview);
+    if (cmd->noptstr) {
+        path.append("?").append(cmd->optstr, cmd->noptstr);
+    }
+
+    if (cmd->npostdata) {
+        htcmd.method = LCB_HTTP_METHOD_POST;
+        htcmd.body = cmd->postdata;
+        htcmd.nbody = cmd->npostdata;
+        htcmd.content_type = "application/json";
+    }
+
+    LCB_CMD_SET_KEY(&htcmd, path.c_str(), path.size());
+    htcmd.reqhandle = &htreq;
+
+    lcb_error_t err = lcb_http3(instance, this, &htcmd);
+    if (err == LCB_SUCCESS) {
+        htreq->set_callback(chunk_callback);
+    }
+    return err;
+}
+
+ViewRequest::ViewRequest(lcb_t instance_, const void *cookie_,
+                         const lcb_CMDVIEWQUERY* cmd)
+    : cur_htresp(NULL), htreq(NULL),
+      parser(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_VIEWS, this)),
+      cookie(cookie_), docq(NULL), callback(cmd->callback),
+      instance(instance_), refcount(1),
+      cmdflags(cmd->cmdflags),
+      lasterr(LCB_SUCCESS) {
+
+    // Validate:
+    if (cmd->nddoc == 0 || cmd->nview == 0 || callback == NULL) {
+        lasterr = LCB_EINVAL;
+    } else if (is_include_docs() && is_no_rowparse()) {
+        lasterr = LCB_OPTIONS_CONFLICT;
+    } else if (cmd->noptstr > MAX_GET_URI_LENGTH) {
+        lasterr = LCB_E2BIG;
+    }
+    if (lasterr != LCB_SUCCESS) {
+        return;
+    }
+
+    if (is_include_docs()) {
+        docq = new lcb::docreq::Queue(instance);
+        docq->parent = this;
+        docq->cb_ready = cb_doc_ready;
+        docq->cb_throttle = cb_docq_throttle;
+        if (cmd->docs_concurrent_max) {
+            docq->max_pending_response = cmd->docs_concurrent_max;
+        }
+    }
+
+    if (cmd->handle) {
+        *cmd->handle = this;
+    }
+
+    lcb_aspend_add(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
+
+    lasterr = request_http(cmd);
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_view_query(lcb_t instance, const void *cookie, const lcb_CMDVIEWQUERY *cmd)
+{
+    ViewRequest *req = new ViewRequest(instance, cookie, cmd);
+    lcb_error_t err = req->lasterr;
+    if (err != LCB_SUCCESS) {
+        req->cancel();
+        delete req;
+    }
+    return err;
+}
+
+LIBCOUCHBASE_API
+void
+lcb_view_query_initcmd(lcb_CMDVIEWQUERY *vq,
+    const char *design, const char *view, const char *options,
+    lcb_VIEWQUERYCALLBACK callback)
+{
+    vq->view = view;
+    vq->nview = strlen(view);
+    vq->ddoc = design;
+    vq->nddoc = strlen(design);
+    if (options != NULL) {
+        vq->optstr = options;
+        vq->noptstr = strlen(options);
+    }
+    vq->callback = callback;
+}
+
+LIBCOUCHBASE_API
+void lcb_view_cancel(lcb_t, lcb_VIEWHANDLE handle) {
+    handle->cancel();
+}
+
+void ViewRequest::cancel() {
+    if (callback) {
+        callback = NULL;
+        lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
+        if (docq) {
+            docq->cancel();
+        }
+    }
+}