libcouchbase 0.0.1

data/ext/libcouchbase/include/libcouchbase/ixmgmt.h

@@ -0,0 +1,263 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 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 LCB_IXMGMT_H
+#define LCB_IXMGMT_H
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/n1ql.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @volatile
+ *
+ * Structure representing a single index definition
+ */
+typedef struct {
+    /**
+     * Raw JSON returned from server.
+     * Can be used to decode fields in future versions not present within the
+     * library.
+     *
+     * This field can also be used as an input field to populate the other
+     * fields in this structure. This means that if you have a raw JSON
+     * representation of an index, you need only set this field (and
+     * `nrawjson`). The library will internally parse the raw JSON and
+     * populate the internal equivalents of the fields in this structure.
+     *
+     * Note that when using this field as an input for creating indexes, you
+     * should still set the ::flags field if you wish to set flags (e.g. in
+     * order to create a deferred-build index).
+     */
+    const char *rawjson;
+    size_t nrawjson;
+
+    /** Name of the index. For raw JSON, use the `name` propery */
+    const char *name;
+    size_t nname;
+
+    /**
+     * Keyspace or "bucket" of the index. For raw JSON, use the
+     * `keyspace_id` property
+     */
+    const char *keyspace;
+    size_t nkeyspace;
+
+    /** 'namespace'. Currently unused */
+    const char *nspace;
+    size_t nnspace;
+
+    /** Output parameter only. State of index */
+    const char *state;
+    size_t nstate;
+
+    /** Actual index text. For raw JSON use the `index_key` property.
+     * The value for this field is a properly-encoded JSON array of fields
+     * to index. e.g.
+     *
+     * @code{c}
+     * spec.fields = "[\"`name`\", \"`email`\", \"`ctime`\"]"
+     * @endcode
+     */
+    const char *fields;
+    size_t nfields;
+
+    /**Indexing condition. If set, only field values matching this condition
+     * will be indexed */
+    const char *cond;
+    size_t ncond;
+
+    /**
+     * Modifiers for the index itself. This might be
+     * LCB_N1XSPEC_F_PRIMARY if the index is primary. For raw JSON,
+     * use `"is_primary":true`
+     *
+     * For creation the LCB_N1XSPEC_F_DEFER option is also accepted to
+     * indicate that the building of this index should be deferred.
+     */
+    unsigned flags;
+
+    /**
+     * Type of this index, Can be LCB_N1XSPEC_T_DEFAULT for the default
+     * server type, or an explicit LCB_N1XSPEC_T_GSI or LCB_N1XSPEC_T_VIEW.
+     * When using JSON, specify `"using":"gsi"`
+     */
+    unsigned ixtype;
+} lcb_N1XSPEC;
+
+/** Input/Output flag. The index is the primary index for the bucket */
+#define LCB_N1XSPEC_F_PRIMARY 1<<16
+
+/**
+ * Input flag for creation. Defer the index building until later. This may
+ * be used to accelerate the building of multiple indexes, so that the index
+ * builder can construct all indexes by scanning items only once
+ */
+#define LCB_N1XSPEC_F_DEFER 1<<17
+
+/**
+ * Input for index type. It's best to just leave this value to 0 (DEFAULT)
+ * unless you know what you're doing.
+ */
+#define LCB_N1XSPEC_T_DEFAULT 0
+#define LCB_N1XSPEC_T_GSI 1
+#define LCB_N1XSPEC_T_VIEW 2
+
+struct lcb_RESPN1XMGMT_st;
+
+/**
+ * Callback for index management operations
+ * @param instance
+ * @param cbtype - set to LCB_CALLBACK_N1XMGMT
+ * @param resp the response structure
+ */
+typedef void (*lcb_N1XMGMTCALLBACK)(lcb_t instance,
+        int cbtype, const struct lcb_RESPN1XMGMT_st *resp);
+
+/**
+ * @volatile
+ * Command for index management operations
+ */
+typedef struct {
+    /**
+     * The index to operate on. This can either be a full definition
+     * (when creating an index)
+     * or a partial definition (when listing or building
+     * indexes)
+     */
+    lcb_N1XSPEC spec;
+
+    /**
+     * Callback to be invoked when operation is complete.
+     */
+    lcb_N1XMGMTCALLBACK callback;
+} lcb_CMDN1XMGMT;
+
+/**
+ * @volatile
+ *
+ * Response structure for index management operations
+ */
+typedef struct lcb_RESPN1XMGMT_st {
+    LCB_RESP_BASE
+
+    /**
+     * A list of pointers to specs. This isn't a simple array of specs because
+     * the spec structure internally is backed by additional internal data.
+     */
+    const lcb_N1XSPEC *const *specs;
+    /** Number of specs */
+    size_t nspecs;
+
+    /** Inner N1QL response. Examine on error */
+    const lcb_RESPN1QL *inner;
+} lcb_RESPN1XMGMT;
+
+/**
+ * @volatile
+ *
+ * Retrieve a list of all indexes in the cluster. If lcb_CMDN1XMGMT::spec
+ * contains entries then the search will be limited to the appropriate criteria.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_list(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ *
+ * Create an index. The index can either be a primary or secondary index, and
+ * it may be created immediately or it may be deferred.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_create(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ * Remove an index.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_drop(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ *
+ * Build defered indexes. This may be used with the @ref LCB_N1XSPEC_F_DEFER
+ * option (see lcb_n1x_create()) to initiate the background creation of
+ * indexes.
+ *
+ * lcb_n1x_watchbuild may be used to wait on the status of those indexes.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_startbuild(lcb_t instance, const void *cookie, const lcb_CMDN1XMGMT *cmd);
+
+/**
+ * @volatile
+ *
+ * Structure used for polling index building statuses
+ */
+typedef struct {
+    /**
+     * Input specs. This should be the specs received from lcb_n1x_startbuild()'s
+     * callback. If you are building from scratch, only the lcb_N1XSPEC::rawjson
+     * and lcb_INDEXSPEC::nrawjson need to be populated
+     */
+    const lcb_N1XSPEC * const *specs;
+    /** Number of specs */
+    size_t nspec;
+
+    /**
+     * Maximum amount of time to wait (microseconds).
+     * If not specified, the default is 30 seconds (30 * 100000)
+     */
+    lcb_U32 timeout;
+
+    /**
+     * How often to check status (microseconds).
+     * Default is 500 milliseconds (500000)
+     */
+    lcb_U32 interval;
+
+    /**
+     * Callback to invoke once the indexes have been built or the timeout
+     * has been reached.
+     *
+     * The callback is only invoked once.
+     */
+    lcb_N1XMGMTCALLBACK callback;
+} lcb_CMDN1XWATCH;
+
+/**
+ * @volatile
+ * Poll indexes being built. This allows you to wait until the specified indexes
+ * which are being built (using lcb_n1x_startbuild()) have been fully
+ * created.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1x_watchbuild(lcb_t instance, const void *cookie, const lcb_CMDN1XWATCH *cmd);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* LCB_IXMGMT_H */

data/ext/libcouchbase/include/libcouchbase/kvbuf.h

@@ -0,0 +1,132 @@
+/* -*- 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 LCB_KVBUF_H
+#define LCB_KVBUF_H
+
+/**
+ * @file
+ *
+ * Low level structures used by commands for buffers.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @brief Flags indicating the storage policy for a buffer */
+typedef enum {
+    LCB_KV_COPY = 0, /**< The buffer should be copied */
+    LCB_KV_CONTIG, /**< The buffer is contiguous and should not be copied */
+    LCB_KV_IOV, /**< The buffer is not contiguous and should not be copied */
+
+    /**For use within the hashkey field, indicates that the _length_
+     * of the hashkey is the vBucket ID, rather than an actual hashkey */
+    LCB_KV_VBID,
+
+    /**
+     * The buffers are not contiguous (multi-part buffers) but should be
+     * copied. This avoids having to make the buffers contiguous before
+     * passing it into the library (only to have the library copy it again) */
+    LCB_KV_IOVCOPY
+} lcb_KVBUFTYPE;
+
+#define LCB_KV_HEADER_AND_KEY LCB_KV_CONTIG
+
+/**
+ * @brief simple buf/length structure for a contiguous series of bytes
+ */
+typedef struct lcb_CONTIGBUF {
+    const void *bytes;
+    /** Number of total bytes */
+    lcb_size_t nbytes;
+} lcb_CONTIGBUF;
+
+/** @brief Common request header for all keys */
+typedef struct lcb_KEYBUF {
+    /**
+     * The type of key to provide. This can currently be LCB_KV_COPY (Default)
+     * to copy the key into the pipeline buffers, or LCB_KV_HEADER_AND_KEY
+     * to provide a buffer with the header storage and the key.
+     *
+     * TODO:
+     * Currently only LCB_KV_COPY should be used. LCB_KV_HEADER_AND_KEY is used
+     * internally but may be exposed later on
+     */
+    lcb_KVBUFTYPE type;
+    lcb_CONTIGBUF contig;
+} lcb_KEYBUF;
+
+/**@private*/
+#define LCB_KEYBUF_IS_EMPTY(k) (k)->contig.nbytes == 0
+
+/**
+ * @brief Initialize a contiguous request backed by a buffer which should be
+ * copied
+ * @param req the key request to initialize
+ * @param k the key to copy
+ * @param nk the size of the key
+ */
+#define LCB_KREQ_SIMPLE(req, k, nk) do { \
+    (req)->type = LCB_KV_COPY; \
+    (req)->contig.bytes = k; \
+    (req)->contig.nbytes = nk; \
+} while (0);
+
+/**
+ * Structure for an IOV buffer to be supplied as a buffer. This is currently
+ * only used for value buffers
+ */
+typedef struct lcb_FRAGBUF {
+    /** An IOV array */
+    lcb_IOV *iov;
+
+    /** Number of elements in iov array */
+    unsigned int niov;
+
+    /**
+     * Total length of the items. This should be set, if known, to prevent the
+     * library from manually traversing the iov array to calculate the length.
+     */
+    unsigned int total_length;
+} lcb_FRAGBUF;
+
+/** @brief Structure representing a value to be stored */
+typedef struct lcb_VALBUF {
+    /**
+     * Value request type. This may be one of:
+     * - LCB_KV_COPY: Copy over the value into LCB's own buffers
+     *   Use the 'contig' field to supply the information.
+     *
+     * - LCB_KV_CONTIG: The buffer is a contiguous chunk of value data.
+     *   Use the 'contig' field to supply the information.
+     *
+     * - LCB_KV_IOV: The buffer is a series of IOV elements. Use the 'multi'
+     *   field to supply the information.
+     */
+    lcb_KVBUFTYPE vtype;
+    union {
+        lcb_CONTIGBUF contig;
+        lcb_FRAGBUF multi;
+    } u_buf;
+} lcb_VALBUF;
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/include/libcouchbase/n1ql.h

@@ -0,0 +1,364 @@
+/*
+ *     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.
+ **/
+
+#ifndef LCB_N1QL_API_H
+#define LCB_N1QL_API_H
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @ingroup lcb-public-api
+ * @defgroup lcb-n1ql-api N1QL
+ * @brief Execute N1QL queries and receive resultant rows
+ */
+
+/**
+ * @addtogroup lcb-n1ql-api
+ * @{
+ */
+typedef struct lcb_RESPN1QL lcb_RESPN1QL;
+typedef struct lcb_CMDN1QL lcb_CMDN1QL;
+typedef struct lcb_N1QLREQ* lcb_N1QLHANDLE;
+
+/**
+ * Callback to be invoked for each row
+ * @param The instance
+ * @param Callback type. This is set to @ref LCB_CALLBACK_N1QL
+ * @param The response.
+ */
+typedef void (*lcb_N1QLCALLBACK)(lcb_t, int, const lcb_RESPN1QL*);
+
+/**
+ * @name N1QL Parameters
+ *
+ * The following APIs simply provide wrappers for creating the proper HTTP
+ * form parameters for N1QL requests. The general flow is to create a
+ * parameters (@ref lcb_N1QLPARAMS) object, set various options and properties
+ * on it, and populate an @ref lcb_CMDN1QL object using the lcb_n1p_mkcmd()
+ * function.
+ *
+ * @{
+ */
+
+/**
+ * Opaque object representing N1QL parameters.
+ * This object is created via lcb_n1p_new(), may be cleared
+ * (for use with another query) via lcb_n1p_reset(), and may be freed via
+ * lcb_n1p_free().
+ */
+typedef struct lcb_N1QLPARAMS_st lcb_N1QLPARAMS;
+
+/**
+ * Create a new N1QL Parameters object. The returned object is an opaque
+ * pointer which may be used to set various properties on a N1QL query. This
+ * may then be used to populate relevant fields of an @ref lcb_CMDN1QL
+ * structure.
+ */
+LIBCOUCHBASE_API
+lcb_N1QLPARAMS *
+lcb_n1p_new(void);
+
+/**
+ * Reset the parameters structure so that it may be reused for a subsequent
+ * query. Internally this resets the buffer positions to 0, but does not free
+ * them, making this function optimal for issusing subsequent queries.
+ * @param params the object to reset
+ */
+LIBCOUCHBASE_API
+void
+lcb_n1p_reset(lcb_N1QLPARAMS *params);
+
+/**
+ * Free the parameters structure. This should be done when it is no longer
+ * needed
+ * @param params the object to reset
+ */
+LIBCOUCHBASE_API
+void
+lcb_n1p_free(lcb_N1QLPARAMS *params);
+
+/** Query is a statement string */
+#define LCB_N1P_QUERY_STATEMENT 1
+
+/** @private */
+#define LCB_N1P_QUERY_PREPARED 2
+
+/**
+ * Sets the actual statement to be executed
+ * @param params the params object
+ * @param qstr the query string (either N1QL statement or prepared JSON)
+ * @param nqstr the length of the string. Set to -1 if NUL-terminated
+ * @param type the type of statement. Should be ::LCB_N1P_QUERY_STATEMENT,
+ *  currently.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_setquery(lcb_N1QLPARAMS *params, const char *qstr, size_t nqstr, int type);
+
+#define lcb_n1p_setstmtz(params, qstr) \
+    lcb_n1p_setquery(params, qstr, -1, LCB_N1P_QUERY_STATEMENT)
+
+/**
+ * Sets a named argument for the query.
+ * @param params the object
+ * @param name The argument name (e.g. `$age`)
+ * @param n_name
+ * @param value The argument value (e.g. `42`)
+ * @param n_value
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_namedparam(lcb_N1QLPARAMS *params, const char *name, size_t n_name,
+    const char *value, size_t n_value);
+
+#define lcb_n1p_namedparamz(params, name, value) \
+    lcb_n1p_namedparam(params, name, -1, value, -1)
+
+/**
+ * Adds a _positional_ argument for the query
+ * @param params the params object
+ * @param value the argument
+ * @param n_value the length of the argument.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_posparam(lcb_N1QLPARAMS *params, const char *value, size_t n_value);
+
+/**
+ * Set a query option
+ * @param params the params object
+ * @param name the name of the option
+ * @param n_name
+ * @param value the value of the option
+ * @param n_value
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_setopt(lcb_N1QLPARAMS *params, const char *name, size_t n_name,
+    const char *value, size_t n_value);
+
+/**
+ * Convenience function to set a string parameter with a string value
+ * @param params the parameter object
+ * @param key the NUL-terminated option name
+ * @param value the NUL-terminated option value
+ */
+#define lcb_n1p_setoptz(params, key, value) \
+    lcb_n1p_setopt(params, key, -1, value, -1)
+
+
+/** No consistency constraints */
+#define LCB_N1P_CONSISTENCY_NONE 0
+
+/**
+ * This is implicitly set by the lcb_n1p_synctok() family of functions. This
+ * will ensure that mutations up to the vector indicated by the mutation token
+ * passed to lcb_n1p_synctok() are used.
+ */
+#define LCB_N1P_CONSISTENCY_RYOW 1
+
+/** Refresh the snapshot for each request */
+#define LCB_N1P_CONSISTENCY_REQUEST 2
+
+/** Refresh the snapshot for each statement */
+#define LCB_N1P_CONSISTENCY_STATEMENT 3
+
+/**
+ * Sets the consistency mode for the request.
+ * By default results are read from a potentially stale snapshot of the data.
+ * This may be good for most cases; however at times you want the absolutely
+ * most recent data.
+ * @param params the parameters object
+ * @param mode one of the `LCB_N1P_CONSISTENT_*` constants.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_setconsistency(lcb_N1QLPARAMS *params, int mode);
+
+/**
+ * Indicate that the query should synchronize its internal snapshot to reflect
+ * the changes indicated by the given mutation token (`ss`).
+ * @param params the parameters object
+ * @param keyspace the keyspace (or bucket name) which this mutation token
+ *        pertains to
+ * @param st the mutation token
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_setconsistent_token(lcb_N1QLPARAMS *params,
+    const char *keyspace, const lcb_MUTATION_TOKEN *st);
+
+/**
+ * Indicate that the query should synchronize its internal snapshot to reflect
+ * any past changes made by the given instance `instance`.
+ *
+ * This iterates over all the vbuckets for the given instance and inserts
+ * the relevant mutation token, using @ref lcb_get_mutation_token
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_setconsistent_handle(lcb_N1QLPARAMS *params, lcb_t instance);
+
+/**
+ * Encodes the request and returns it as a string. The string is valid
+ * until the next call to the params function.
+ * @param params the parameter object
+ * @param[out] rc an error code if there was an issue in encoding
+ * @return the NUL-terminated query string.
+ *
+ * @note Calling this function regenerates the query string internally,
+ *       and is implicitly called by lcb_n1p_mkcmd().
+ */
+LIBCOUCHBASE_API
+const char *
+lcb_n1p_encode(lcb_N1QLPARAMS *params, lcb_error_t *rc);
+
+/**
+ * Populates the given low-level lcb_CMDN1QL structure with the relevant fields
+ * from the params structure. If this function returns successfuly, you must
+ * ensure that the params object is not modified until the command is
+ * submitted.
+ *
+ * @note
+ * This may also set some lcb_CMDN1QL::cmdflags fields. If setting your own
+ * flags, ensure that those flags do not replace the existing ones set by
+ * this function.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1p_mkcmd(lcb_N1QLPARAMS *params, lcb_CMDN1QL *cmd);
+
+/**@}*/
+
+/**
+ * @name Low-level N1QL interface
+ * @{
+ */
+
+/**
+ * Prepare and cache the query if required. This may be used on frequently
+ * issued queries, so they perform better.
+ */
+#define LCB_CMDN1QL_F_PREPCACHE 1<<16
+
+/** @private The lcb_CMDN1QL::query member is an internal JSON structure */
+#define LCB_CMDN1QL_F_JSONQUERY 1<<17
+
+/**
+ * Command structure for N1QL queries. Typically an application will use the
+ * lcb_N1QLPARAMS structure to populate the #query and #content_type fields.
+ *
+ * The #callback field must be specified, and indicates the function the
+ * library should call when more response data has arrived.
+ */
+struct lcb_CMDN1QL {
+    lcb_U32 cmdflags;
+    /**Query to be placed in the POST request. The library will not perform
+     * any conversions or validation on this string, so it is up to the user
+     * (or wrapping library) to ensure that the string is well formed.
+     *
+     * If using the @ref lcb_N1QLPARAMS structure, the lcb_n1p_mkcmd() function
+     * will properly populate this field.
+     *
+     * In general the string should either be JSON (in which case, the
+     * #content_type field should be `application/json`) or url-encoded
+     * (in which case the #content_type field should be
+     * `application/x-www-form-urlencoded`)
+     */
+    const char *query;
+
+    /** Length of the query data */
+    size_t nquery;
+
+    /** Ignored since version 2.5.3 */
+    const char *host;
+
+    /** Ignored since version 2.5.3 */
+    const char *content_type;
+
+    /** Callback to be invoked for each row */
+    lcb_N1QLCALLBACK callback;
+
+    /**Request handle. Will be set to the handle which may be passed to
+     * lcb_n1ql_cancel() */
+    lcb_N1QLHANDLE *handle;
+};
+
+/**
+ * Response for a N1QL query. This is delivered in the @ref lcb_N1QLCALLBACK
+ * callback function for each result row received. The callback is also called
+ * one last time when all
+ */
+struct lcb_RESPN1QL {
+    #ifndef __LCB_DOXYGEN__
+    LCB_RESP_BASE
+    #else
+    lcb_U16 rflags; /**< Flags for response structure */
+    #endif
+
+    /**Current result row. If #rflags has the ::LCB_RESP_F_FINAL bit set, then
+     * this field does not contain the actual row, but the remainder of the
+     * data not included with the resultset; e.g. the JSON surrounding
+     * the "results" field with any errors or metadata for the response.
+     */
+    const char *row;
+    /** Length of the row */
+    size_t nrow;
+    /** Raw HTTP response, if applicable */
+    const lcb_RESPHTTP *htresp;
+};
+
+/**
+ * @volatile
+ *
+ * Execute a N1QL query.
+ *
+ * This function will send the query to a query server in the cluster
+ * and will invoke the callback (lcb_CMDN1QL::callback) for each result returned.
+ *
+ * @param instance The instance
+ * @param cookie Pointer to application data
+ * @param cmd the command
+ * @return Scheduling success or failure.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_n1ql_query(lcb_t instance, const void *cookie, const lcb_CMDN1QL *cmd);
+
+
+/**
+ * Cancels an in-progress request. This will ensure that further callbacks
+ * for the given request are not delivered.
+ *
+ * @param instance the instance
+ * @param handle the handle for the request. This is obtained during the
+ *  request as an 'out' parameter (see lcb_CMDN1QL::handle)
+ */
+LIBCOUCHBASE_API
+void
+lcb_n1ql_cancel(lcb_t instance, lcb_N1QLHANDLE handle);
+/**@}*/
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+#endif