libcouchbase 0.0.1

data/ext/libcouchbase/src/n1ql/params.cc

@@ -0,0 +1,215 @@
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/n1ql.h>
+#include <libcouchbase/vbucket.h>
+#include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
+#include <string>
+
+#define SCANVEC_NONE 0
+#define SCANVEC_PARTIAL 1
+#define SCANVEC_FULL 2
+
+struct lcb_N1QLPARAMS_st {
+    Json::Value root;
+    std::string encoded;
+
+    lcb_N1QLPARAMS_st() : root(Json::objectValue) {
+    }
+};
+
+extern "C" {
+static size_t get_strlen(const char *s, size_t n)
+{
+    if (n == (size_t)-1) {
+        return strlen(s);
+    } else {
+        return n;
+    }
+}
+
+static lcb_error_t
+setopt(lcb_N1QLPARAMS *params, const char *k, size_t nk, const char *v, size_t nv)
+{
+    nv = get_strlen(v, nv);
+    nk = get_strlen(k, nk);
+    Json::Reader rdr;
+    Json::Value value;
+    bool rv = rdr.parse(v, v + nv, value);
+    if (!rv) {
+        return LCB_EINVAL;
+    }
+
+    params->root[std::string(k, nk)] = value;
+    return LCB_SUCCESS;
+}
+
+lcb_error_t
+lcb_n1p_setopt(lcb_N1QLPARAMS *params,
+    const char *k, size_t nk, const char *v, size_t nv)
+{
+    return setopt(params, k, nk, v, nv);
+}
+
+lcb_error_t
+lcb_n1p_setquery(lcb_N1QLPARAMS *params,
+    const char *qstr, size_t nqstr, int type)
+{
+    if (type == LCB_N1P_QUERY_STATEMENT) {
+        size_t nstmt = get_strlen(qstr, nqstr);
+        params->root["statement"] = std::string(qstr, nstmt);
+        return LCB_SUCCESS;
+    } else if (type == LCB_N1P_QUERY_PREPARED) {
+        return lcb_n1p_setopt(params, "prepared", -1, qstr, nqstr);
+    } else {
+        return LCB_EINVAL;
+    }
+}
+
+lcb_error_t
+lcb_n1p_namedparam(lcb_N1QLPARAMS *params,
+    const char *name, size_t nname, const char *value, size_t nvalue)
+{
+    return lcb_n1p_setopt(params, name, nname, value, nvalue);
+}
+
+lcb_error_t
+lcb_n1p_posparam(lcb_N1QLPARAMS *params, const char *value, size_t nvalue)
+{
+    nvalue = get_strlen(value, nvalue);
+    Json::Value jval;
+    Json::Reader rdr;
+    if (!rdr.parse(value, value + nvalue, jval)) {
+        return LCB_EINVAL;
+    }
+    params->root["args"].append(jval);
+    return LCB_SUCCESS;
+}
+
+static void
+encode_mutation_token(Json::Value& sparse, const lcb_MUTATION_TOKEN *sv)
+{
+    char buf[64] = { 0 };
+    sprintf(buf, "%u", sv->vbid_);
+    Json::Value& cur_sv = sparse[buf];
+
+    cur_sv[0] = static_cast<Json::UInt64>(sv->seqno_);
+    sprintf(buf, "%llu", sv->uuid_);
+    cur_sv[1] = buf;
+}
+
+lcb_error_t
+lcb_n1p_setconsistent_token(lcb_N1QLPARAMS *params,
+    const char *keyspace, const lcb_MUTATION_TOKEN *sv)
+{
+    if (!LCB_MUTATION_TOKEN_ISVALID(sv)) {
+        return LCB_EINVAL;
+    }
+
+    params->root["scan_consistency"] = "at_plus";
+    encode_mutation_token(params->root["scan_vector"][keyspace], sv);
+    return LCB_SUCCESS;
+}
+
+lcb_error_t
+lcb_n1p_setconsistent_handle(lcb_N1QLPARAMS *params, lcb_t instance)
+{
+    lcbvb_CONFIG *vbc;
+    lcb_error_t rc = lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_VBCONFIG, &vbc);
+    if (rc != LCB_SUCCESS) {
+        return rc;
+    }
+
+    const char *bucketname;
+    rc = lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_BUCKETNAME, &bucketname);
+    if (rc != LCB_SUCCESS) {
+        return rc;
+    }
+
+    Json::Value* sv_json = NULL;
+
+    size_t vbmax = vbc->nvb;
+    for (size_t ii = 0; ii < vbmax; ++ii) {
+        lcb_KEYBUF kb;
+        kb.type = LCB_KV_VBID;
+        kb.contig.nbytes = ii;
+        kb.contig.bytes = NULL;
+        const lcb_MUTATION_TOKEN *mt = lcb_get_mutation_token(instance, &kb, &rc);
+        if (rc == LCB_SUCCESS && mt != NULL) {
+            if (sv_json == NULL) {
+                sv_json = &params->root["scan_vectors"][bucketname];
+                params->root["scan_consistency"] = "at_plus";
+            }
+            encode_mutation_token(*sv_json, mt);
+        }
+    }
+
+    if (!sv_json) {
+        return LCB_KEY_ENOENT;
+    }
+
+    return LCB_SUCCESS;
+}
+
+lcb_error_t
+lcb_n1p_setconsistency(lcb_N1QLPARAMS *params, int mode)
+{
+    if (mode == LCB_N1P_CONSISTENCY_NONE) {
+        params->root.removeMember("scan_consistency");
+    } else if (mode == LCB_N1P_CONSISTENCY_REQUEST) {
+        params->root["scan_consistency"] = "request_plus";
+    } else if (mode == LCB_N1P_CONSISTENCY_STATEMENT) {
+        params->root["scan_consistency"] = "statement_plus";
+    }
+    return LCB_SUCCESS;
+}
+
+LIBCOUCHBASE_API
+const char *
+lcb_n1p_encode(lcb_N1QLPARAMS *params, lcb_error_t *err)
+{
+    lcb_error_t err_s = LCB_SUCCESS;
+    if (!err) {
+        err = &err_s;
+    }
+
+    *err = LCB_SUCCESS;
+    /* Build the query */
+    Json::FastWriter w;
+    params->encoded = w.write(params->root);
+    return params->encoded.c_str();
+}
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_mkcmd(lcb_N1QLPARAMS *params, lcb_CMDN1QL *cmd)
+{
+    lcb_error_t rc = LCB_SUCCESS;
+    lcb_n1p_encode(params, &rc);
+    if (rc != LCB_SUCCESS) {
+        return rc;
+    }
+    cmd->content_type = "application/json";
+    cmd->query = params->encoded.c_str();
+    cmd->nquery = params->encoded.size();
+    return LCB_SUCCESS;
+}
+
+lcb_N1QLPARAMS *
+lcb_n1p_new(void)
+{
+    return new lcb_N1QLPARAMS;
+}
+
+void
+lcb_n1p_reset(lcb_N1QLPARAMS *params)
+{
+    params->encoded.clear();
+    params->root.clear();
+}
+
+void
+lcb_n1p_free(lcb_N1QLPARAMS *params)
+{
+    delete params;
+}
+
+} // extern C

data/ext/libcouchbase/src/netbuf/netbuf-defs.h

@@ -0,0 +1,89 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 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.
+ */
+
+#ifndef NETBUF_DEFS_H
+#define NETBUF_DEFS_H
+
+typedef struct netbuf_st nb_MGR;
+typedef unsigned int nb_SIZE;
+
+/**
+ * @file
+ * Netbuf Core Structures
+ * @addtogroup netbufs
+ * @{
+ */
+
+/**
+ * @name Cache Allocation
+ * @{
+ *
+ * The following settings control the default allocation policy.
+ * Each allocator pool has both blocks and the amount of data per block.
+ *
+ * Multiple blocks help with cache locality when traversing, while large
+ * data segements allow each individual element to be spaced near the next.
+ */
+
+/** @brief How many blocks to preallocate for SNDQ elements, per manager */
+#define NB_SNDQ_CACHEBLOCKS 4
+/** @brief How many SNDQELEM structures per block */
+#define NB_SNDQ_BASEALLOC 128
+
+
+/** @brief How many dealloc blocks to allocated per MBLOCK */
+#define NB_MBDEALLOC_CACHEBLOCKS 0
+/** @brief Number of dealloc structures per block */
+#define NB_MBDEALLOC_BASEALLOC 24
+
+
+/** @brief How many data blocks to allocate per manager */
+#define NB_DATA_CACHEBLOCKS 16
+/** @brief Default data allocation size */
+#define NB_DATA_BASEALLOC 32768
+/**@}*/
+
+typedef struct {
+    nb_SIZE sndq_cacheblocks;
+    nb_SIZE sndq_basealloc;
+    nb_SIZE dea_cacheblocks;
+    nb_SIZE dea_basealloc;
+    nb_SIZE data_cacheblocks;
+    nb_SIZE data_basealloc;
+} nb_SETTINGS;
+
+#ifndef _WIN32
+typedef struct {
+    void *iov_base;
+    size_t iov_len;
+} nb_IOV;
+
+/**Macro which serves as a static initializer for an nb_IOV. This works
+ * on both Windows and Unix despite the layout of the structure being different
+ */
+#define NETBUF_IOV_INIT(base, len) { base, len }
+#else
+typedef struct {
+    ULONG iov_len;
+    void *iov_base;
+} nb_IOV;
+#define NETBUF_IOV_INIT(base, len) { len, base }
+#endif
+
+/**@}*/
+
+#endif /* NETBUF_DEFS_H */

data/ext/libcouchbase/src/netbuf/netbuf-mblock.h

@@ -0,0 +1,235 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 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.
+ */
+
+#ifndef NETBUF_MBLOCK_H
+#define NETBUF_MBLOCK_H
+
+#include "netbuf-defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file
+ *
+ * @ingroup netbufs
+ * @defgroup netbufs-mblock Netbuf Block Allocator
+ * @details
+ *
+ * Managed block in-order allocator.
+ *
+ * This allocator attempts to provide unaligned segments of memory in the
+ * order they were allocated in contiguous memory
+ *
+ * @verbatim
+ *
+ * LEGEND
+ * In the following comments (and within the source as well) we will try to
+ * display diagrams of blocks. The following symbols will be used:
+ *
+ * {$:NN} = This represents a position marker, $ will be the position type,
+ *          and NN is the offset value.
+ *
+ * The following are the position types:
+ *
+ * [S]tart       Start of the buffer (block->start)
+ * [W]rap        Wrapping and end of the first segment (block->wrap)
+ * [C]ursor      End of the current segment (block->cursor)
+ * [A]lloc       Allocation limit of the buffer (block->nalloc)
+ * [F]lush       Flush cursor (block->flushcur)
+ *
+ * Note that in some cases two position types may share the same offset.
+ *
+ * Between any of the offsets, there are data bytes (or just "Data"). These
+ * may be one of the following:
+ *
+ * [x]           Used data. This data is owned by a span
+ * [o]           Unused data, but available for usage
+ * [-]           Unreachable data. This is not used but cannot be reserved
+ *
+ * A block contains a single allocated buffer. The buffer itself may be
+ * divided among multiple spans. We divide our buffers like so:
+ *
+ * Initially:
+ *
+ * [ {FS:0}xxxxxxx{CW:10}ooo{A:12} ]
+ *
+ * After flushing some data:
+ *
+ * [ {S:0}xx{F:5}xxxx{CW:10}oo{A:12} ]
+ * Note how the flush cursor is incremented
+ *
+ *
+ * Typically, once data is flushed, the user will release the segment, and thus
+ * will look something like this:
+ *
+ * [ ooo{SF:6}xxxx{CW:10}oooo{A:12} ]
+ *
+ * Appending data to a buffer (or reserving a span) depends on the span
+ * size requirements. In this case, if a span's size is 2 bytes or lower,
+ * it is appended at the end of the first segment, like so:
+ * [ ooo{SF:16}xxxxxx{CWA:12} ]
+ *
+ * Otherwise, it is wrapped around, like so:
+ *
+ * [ xx{C:3}oo{SF:6}xxxx{W:10}--{A:12} ]
+ *
+ * Note that [C] has been wrapped around to start at 3.
+ *
+ *
+ * The total size of the block's used portion is as follows:
+ *
+ * (1) The number of bytes between [S]tart and [Wrap]
+ * (2) If [C] != [W], then also add the value of [C]
+ * @endverbatim
+ * @addtogroup netbufs-mblock
+ * @{
+ */
+
+struct netbuf_mblock_st;
+struct netbuf_st;
+struct netbuf_mblock_dealloc_queue_st;
+
+/**
+ * Small header for larger structures to more efficiently find the block
+ * they were allocated in.
+ *
+ * Note that it is possible to also determine this information by traversing
+ * the list of all blocks, but this is naturally less efficient.
+ */
+typedef struct {
+    /** The parent block */
+    struct netbuf_mblock_st *parent;
+    /** The allocation offset */
+    nb_SIZE offset;
+} nb_ALLOCINFO;
+
+/**
+ * @brief Structure for an out-of-order dealloc
+ */
+typedef struct {
+    sllist_node slnode;
+    nb_SIZE offset; /**< Offset into the nb_MBLOCK to release */
+    nb_SIZE size; /**< Size to release */
+} nb_QDEALLOC;
+
+/**
+ * @brief Data Block
+ * This structure represents the head of an `MBLOCK`.
+ */
+typedef struct {
+    sllist_node slnode;
+
+    /** Start position for data */
+    nb_SIZE start;
+
+    /**
+     * Wrap/End position for data. If the block has only one segment,
+     * this is always equal to cursor (see below)
+     * and will mark the position at which the unused portion of the
+     * buffer begins.
+     *
+     * If the block has two segments, this marks the end of the first segment.
+     *
+     * In both cases
+     *  1. `wrap` is always `> start`
+     *  2. `wrap-start` is the length of the first segment of data
+     */
+    nb_SIZE wrap;
+
+    /**
+     * End position for data. This always contains the position at which
+     * the unused data begins.
+     *
+     * If the block only has a single segment then both the following are true:
+     *
+     *  1. `cursor == wrap`
+     *  2. `cursor > start` (if not empty)
+     *
+     * If the block has two segments, then both the following are true:
+     *
+     *  1. `cursor != wrap`
+     *  2. `cursor < start`
+     *
+     * If the block is empty:
+     *  - `cursor == start`
+     */
+    nb_SIZE cursor;
+
+    /**
+     * Total number of bytes allocated in `root`. This represents the absolute
+     * limit on how much data can be supplied
+     */
+    nb_SIZE nalloc;
+
+    /**
+     * Actual allocated buffer. This remains constant for the duration of the
+     * block's lifetime
+     */
+    char *root;
+
+    /**
+     * Pointer to a nb_DEALLOC_QUEUE structure. This is only valid if an
+     * out-of-order dealloc has been performed on this block.
+     */
+    struct netbuf_mblock_dealloc_queue_st *deallocs;
+    struct netbuf_mblock_st *parent;
+} nb_MBLOCK;
+
+/**
+ * @brief pool of nb_MBLOCK structures
+ */
+typedef struct netbuf_mblock_st {
+    /** Active blocks that have at least one reserved span */
+    sllist_root active;
+
+    /** Available blocks with data */
+    sllist_root avail;
+
+    /** Allocation size */
+    nb_SIZE basealloc;
+
+    /** Maximum number of non-cached blocks */
+    unsigned int maxblocks;
+
+    /** Current number of non-cached blocks */
+    unsigned int curblocks;
+
+    nb_MBLOCK *cacheblocks;
+    nb_SIZE ncacheblocks;
+
+    struct netbuf_st *mgr;
+} nb_MBPOOL;
+
+/**
+ * @brief List of out-of-order deallocs
+ * This is attached to an nb_MBLOCK structure if allocations have been performed
+ * on it in an out-of-order fashion
+ */
+typedef struct netbuf_mblock_dealloc_queue_st {
+    sllist_root pending;
+    nb_SIZE min_offset; /**< The first offset contained in the list */
+    nb_MBPOOL qpool; /**< Used to allcate the nb_QDEALLOC structures themselves*/
+} nb_DEALLOC_QUEUE;
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+#endif