prefs results from the CPAN

Pongo

view release on metacpan or search on metacpan

mongoc_kms_credentials_provider_callback_fn T_PTROBJ
mongoc_tls_opts_t* T_PTROBJ
mongoc_bulkwrite_insertoneopts_t* T_PTROBJ
mongoc_bulkwrite_t* T_PTROBJ
const mongoc_bulkwrite_insertoneopts_t* T_PTROBJ
bson_error_t* T_PTROBJ
mongoc_bulkwrite_updateoneopts_t* T_PTROBJ
const mongoc_bulkwrite_updateoneopts_t* T_PTROBJ
mongoc_bulkwrite_updatemanyopts_t* T_PTROBJ
const bson_value_t* T_PTROBJ
const mongoc_bulkwrite_updatemanyopts_t* T_PTROBJ
mongoc_bulkwrite_replaceoneopts_t* T_PTROBJ
const mongoc_bulkwrite_replaceoneopts_t * T_PTROBJ
mongoc_bulkwrite_deleteoneopts_t* T_PTROBJ
const mongoc_bulkwrite_deleteoneopts_t* T_PTROBJ
mongoc_bulkwrite_deletemanyopts_t* T_PTROBJ
const mongoc_bulkwrite_deletemanyopts_t* T_PTROBJ
mongoc_bulkwritereturn_t T_PTROBJ
const mongoc_bulkwriteopts_t* T_PTROBJ
mongoc_bulkwriteresult_t* T_PTROBJ
mongoc_bulkwriteexception_t* T_PTROBJ
mongoc_client_session_t* T_PTROBJ
mongoc_bulkwriteopts_t* T_PTROBJ
const mongoc_write_concern_t * T_PTROBJ
uint32_t T_PTROBJ
int64_t T_PTROBJ
int32_t T_PTROBJ
const mongoc_bulkwriteresult_t* T_PTROBJ
const mongoc_bulkwriteexception_t * T_PTROBJ
mongoc_bulk_operation_t * T_PTROBJ
bson_t * T_PTROBJ
const mongoc_bulk_operation_t * T_PTROBJ
mongoc_change_stream_t * T_PTROBJ
const mongoc_collection_t * T_PTROBJ
const bson_t ** T_PTROBJ
mongoc_client_encryption_t * T_PTROBJ
mongoc_client_encryption_opts_t * T_PTROBJ
const mongoc_client_encryption_datakey_opts_t * T_PTROBJ
bson_value_t * T_PTROBJ
mongoc_collection_t * T_PTROBJ
mongoc_client_encryption_rewrap_many_datakey_result_t * T_PTROBJ
const mongoc_client_encryption_t * T_PTROBJ
size_t * T_PTROBJ
mongoc_cursor_t * T_PTROBJ
mongoc_client_encryption_encrypt_opts_t * T_PTROBJ
mongoc_client_encryption_datakey_opts_t * T_PTROBJ
const uint8_t * T_PTROBJ
const mongoc_client_encryption_encrypt_range_opts_t * T_PTROBJ
mongoc_client_encryption_encrypt_range_opts_t * T_PTROBJ
const mongoc_uri_t * T_PTROBJ
mongoc_apm_callbacks_t * T_PTROBJ
const mongoc_server_api_t * T_PTROBJ
const mongoc_ssl_opt_t * T_PTROBJ
const mongoc_transaction_opt_t * T_PTROBJ
const mongoc_client_session_t * T_PTROBJ
mongoc_transaction_state_t T_PTROBJ
mongoc_client_session_with_transaction_cb_t T_PTROBJ
const mongoc_session_opt_t * T_PTROBJ
mongoc_server_description_t ** T_PTROBJ
uint32_t * T_PTROBJ
const mongoc_read_prefs_t * T_PTROBJ
mongoc_query_flags_t T_PTROBJ
const mongoc_client_t * T_PTROBJ
char ** T_PTROBJ
mongoc_gridfs_t * T_PTROBJ
mongoc_server_description_t * T_PTROBJ
mongoc_read_prefs_t * T_PTROBJ
const mongoc_read_concern_t * T_PTROBJ
mongoc_session_opt_t * T_PTROBJ
mongoc_stream_initiator_t T_PTROBJ
mongoc_index_model_t * T_PTROBJ
const mongoc_index_opt_t * T_PTROBJ
mongoc_index_model_t ** T_PTROBJ
mongoc_delete_flags_t T_PTROBJ
const mongoc_find_and_modify_opts_t * T_PTROBJ
mongoc_insert_flags_t T_PTROBJ
mongoc_remove_flags_t T_PTROBJ
mongoc_update_flags_t T_PTROBJ
mongoc_host_list_t * T_PTROBJ
const mongoc_cursor_t * T_PTROBJ
const mongoc_database_t * T_PTROBJ
mongoc_find_and_modify_opts_t * T_PTROBJ
mongoc_find_and_modify_flags_t T_PTROBJ
const mongoc_find_and_modify_flags_t T_PTROBJ
mongoc_gridfs_file_list_t * T_PTROBJ
mongoc_gridfs_file_t * T_PTROBJ
mongoc_gridfs_file_opt_t T_PTROBJ
mongoc_iovec_t * T_PTROBJ
const mongoc_iovec_t * T_PTROBJ
uint64_t T_PTROBJ
mongoc_index_opt_geo_t T_PTROBJ
mongoc_stream_t * T_PTROBJ
mongoc_gridfs_bucket_t * T_PTROBJ
mongoc_gridfs_file_opt_t * T_PTROBJ
const mongoc_index_opt_wt_t * T_PTROBJ
const mongoc_optional_t * T_PTROBJ
mongoc_optional_t * T_PTROBJ
const void * T_PTROBJ
mongoc_index_opt_wt_t * T_PTROBJ
mongoc_read_concern_t * T_PTROBJ
mongoc_read_mode_t T_PTROBJ
mongoc_reply_flags_t T_PTROBJ
mongoc_stream_buffered_t T_PTROBJ
mongoc_stream_file_t T_PTROBJ
mongoc_stream_tls_t T_PTROBJ
mongoc_server_api_t * T_PTROBJ
mongoc_server_api_version_t T_PTROBJ
mongoc_server_api_version_t * T_PTROBJ
mongoc_stream_file_t * T_PTROBJ
mongoc_stream_socket_t * T_PTROBJ
mongoc_socket_t * T_PTROBJ
const mongoc_server_description_t * T_PTROBJ
const struct sockaddr * T_PTROBJ
mongoc_socklen_t T_PTROBJ
mongoc_socklen_t * T_PTROBJ
struct sockaddr * T_PTROBJ
mongoc_transaction_opt_t * T_PTROBJ
mongoc_topology_description_t * T_PTROBJ
const mongoc_topology_description_t * T_PTROBJ
const mongoc_index_opt_geo_t * T_PTROBJ
mongoc_index_opt_geo_t * T_PTROBJ
mongoc_index_opt_t * T_PTROBJ
mongoc_uri_t * T_PTROBJ
mongoc_write_concern_t * T_PTROBJ
const mongoc_host_list_t * T_PTROBJ
uint16_t T_PTROBJ

lib/Pongo/Client.xs view on Meta::CPAN

    CODE:
        RETVAL = mongoc_client_session_get_cluster_time(session);
    OUTPUT:
        RETVAL

bool
client_session_get_dirty(session)
    const mongoc_client_session_t *session;
    CODE:
        RETVAL = mongoc_client_session_get_dirty(session);
    OUTPUT:
        RETVAL

void
client_session_get_operation_time(session, timestamp, increment)
    const mongoc_client_session_t *session;
    uint32_t *timestamp;
    uint32_t *increment;
    CODE:
        mongoc_client_session_get_operation_time(session, timestamp, increment);

const mongoc_session_opt_t *
client_session_get_opts(session)
    const mongoc_client_session_t *session;
    CODE:
        RETVAL = mongoc_client_session_get_opts(session);
    OUTPUT:
        RETVAL

const bson_t *
client_session_get_lsid(session)
    mongoc_client_session_t *session;
    CODE:
        RETVAL = mongoc_client_session_get_lsid(session);
    OUTPUT:
        RETVAL

uint32_t
client_session_get_server_id(session)
    const mongoc_client_session_t *session;
    CODE:
        RETVAL = mongoc_client_session_get_server_id(session);
    OUTPUT:
        RETVAL

void
client_session_destroy(session)
    mongoc_client_session_t *session;
    CODE:
        mongoc_client_session_destroy(session);

mongoc_bulkwrite_t *
client_bulkwrite_new(self)
    mongoc_client_t *self;
    CODE:
        RETVAL = mongoc_client_bulkwrite_new(self);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
client_command(client, db_name, flags, skip, limit, batch_size, query, fields, read_prefs)
    mongoc_client_t *client;
    const char *db_name;
    mongoc_query_flags_t flags;
    uint32_t skip;
    uint32_t limit;
    uint32_t batch_size;
    const bson_t *query;
    const bson_t *fields;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_client_command(client, db_name , flags, skip, limit, batch_size, query, fields, read_prefs);
    OUTPUT:
        RETVAL

bool
client_command_simple(client, db_name, command, read_prefs, reply, error)
    mongoc_client_t *client;
    const char *db_name;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_command_simple(client, db_name, command, read_prefs, reply, error);
    OUTPUT:
        RETVAL

bool
client_command_simple_with_server_id(client, db_name, command, read_prefs, server_id, reply, error)
    mongoc_client_t * client;
    const char *db_name;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    uint32_t server_id;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_command_simple_with_server_id(client, db_name, command, read_prefs, server_id, reply, error);
    OUTPUT:
        RETVAL

bool
client_command_with_opts(client, db_name, command, read_prefs, opts, reply, error)
    mongoc_client_t *client;
    const char *db_name;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_command_with_opts(client, db_name, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

void
client_destroy(client)
    mongoc_client_t *client;
    CODE:
        mongoc_client_destroy(client);

bool
client_enable_auto_encryption(client, opts, error)
    mongoc_client_t *client;
    mongoc_auto_encryption_opts_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_enable_auto_encryption(client, opts, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
client_find_databases_with_opts(client, opts)
    mongoc_client_t *client;
    const bson_t *opts;
    CODE:
        RETVAL = mongoc_client_find_databases_with_opts(client, opts);
    OUTPUT:
        RETVAL

mongoc_collection_t *
client_get_collection(client, db, collection)
    mongoc_client_t *client;
    const char *db;
    const char *collection;
    CODE:
        RETVAL = mongoc_client_get_collection(client, db, collection);
    OUTPUT:
        RETVAL

const char *
client_get_crypt_shared_version(client)
    const mongoc_client_t *client;
    CODE:
        RETVAL = mongoc_client_get_crypt_shared_version(client);
    OUTPUT:
        RETVAL

mongoc_database_t *
client_get_database(client, name)
    mongoc_client_t *client;
    const char *name;
    CODE:
        RETVAL = mongoc_client_get_database(client, name);
    OUTPUT:
        RETVAL

char **
client_get_database_names(client, error)
    mongoc_client_t *client;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_get_database_names(client, error);
    OUTPUT:
        RETVAL

char **
client_get_database_names_with_opts(client, opts, error)
    mongoc_client_t  *client;
    const bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_get_database_names_with_opts(client, opts, error);
    OUTPUT:
        RETVAL

mongoc_database_t *
client_get_default_database(client)
    mongoc_client_t *client;
    CODE:
        RETVAL = mongoc_client_get_default_database(client);
    OUTPUT:
        RETVAL

mongoc_gridfs_t *
client_get_gridfs(client, db, prefix, error)
    mongoc_client_t *client;
    const char *db;
    const char *prefix;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_get_gridfs(client, db, prefix, error);
    OUTPUT:
        RETVAL

mongoc_server_description_t *
client_get_handshake_description(client, server_id, opts, error)
    mongoc_client_t *client;
    uint32_t server_id;
    bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_get_handshake_description(client, server_id, opts, error);
    OUTPUT:
        RETVAL

const mongoc_read_concern_t *
client_get_read_concern(client)
    const mongoc_client_t *client;
    CODE:
        RETVAL = mongoc_client_get_read_concern(client);
    OUTPUT:
        RETVAL

const mongoc_read_prefs_t *
client_get_read_prefs(client)
    const mongoc_client_t *client;
    CODE:
        RETVAL = mongoc_client_get_read_prefs(client);
    OUTPUT:
        RETVAL

mongoc_server_description_t *
client_get_server_description(client, server_id)
    mongoc_client_t *client;
    uint32_t server_id;
    CODE:
        RETVAL = mongoc_client_get_server_description(client, server_id);
    OUTPUT:
        RETVAL

mongoc_server_description_t **
client_get_server_descriptions(client, n)
    const mongoc_client_t *client;
    size_t *n;
    CODE:
        RETVAL = mongoc_client_get_server_descriptions(client, n);
    OUTPUT:
        RETVAL

bool
client_get_server_status(client, read_prefs, reply, error)
    mongoc_client_t *client;
    mongoc_read_prefs_t *read_prefs;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_get_server_status(client, read_prefs, reply, error);
    OUTPUT:
        RETVAL

const mongoc_uri_t *
client_get_uri(client)
    const mongoc_client_t *client;
    CODE:
        RETVAL = mongoc_client_get_uri(client);
    OUTPUT:
        RETVAL

const mongoc_write_concern_t *
client_get_write_concern(client)
    const mongoc_client_t *client;
    CODE:
        RETVAL = mongoc_client_get_write_concern(client);
    OUTPUT:
        RETVAL

mongoc_client_t *
client_new(uri_string)
    const char *uri_string;
    CODE:
        RETVAL = mongoc_client_new(uri_string);
    OUTPUT:
        RETVAL

mongoc_client_t *
client_new_from_uri(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_client_new_from_uri(uri);
    OUTPUT:
        RETVAL

mongoc_client_t *
client_new_from_uri_with_error(uri, error)
    const mongoc_uri_t *uri;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_new_from_uri_with_error(uri, error);
    OUTPUT:
        RETVAL

bool
client_read_command_with_opts(client, db_name, command, read_prefs, opts, reply, error)
    mongoc_client_t *client;
    const char *db_name;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_read_command_with_opts(client, db_name, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

bool
client_read_write_command_with_opts(client, db_name, command, read_prefs, opts, reply, error)
    mongoc_client_t *client;
    const char *db_name;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_read_write_command_with_opts(client, db_name, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

void
client_reset(client)
    mongoc_client_t *client;
    CODE:
        mongoc_client_reset(client);

mongoc_server_description_t *
client_select_server(client, for_writes, prefs, error)
    mongoc_client_t *client;
    bool for_writes;
    const mongoc_read_prefs_t *prefs;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_select_server(client, for_writes, prefs, error);
    OUTPUT:
        RETVAL

bool
client_set_apm_callbacks(client, callbacks, context)
    mongoc_client_t *client;
    mongoc_apm_callbacks_t *callbacks;
    void *context;
    CODE:
        RETVAL = mongoc_client_set_apm_callbacks(client, callbacks, context);
    OUTPUT:
        RETVAL

bool
client_set_appname(client, appname)
    mongoc_client_t *client;
    const char *appname;
    CODE:
        RETVAL = mongoc_client_set_appname(client, appname);
    OUTPUT:
        RETVAL

bool
client_set_error_api(client, version)
    mongoc_client_t *client;
    int32_t version;
    CODE:
        RETVAL = mongoc_client_set_error_api(client, version);
    OUTPUT:
        RETVAL

void
client_set_read_concern(client, read_concern)
    mongoc_client_t *client;
    const mongoc_read_concern_t *read_concern;
    CODE:
        mongoc_client_set_read_concern(client, read_concern);

void
client_set_read_prefs(client, read_prefs)
    mongoc_client_t *client;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        mongoc_client_set_read_prefs(client, read_prefs);

bool
client_set_server_api(client, api, error)
    mongoc_client_t *client;
    const mongoc_server_api_t *api;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_set_server_api(client, api, error);
    OUTPUT:
        RETVAL

void
client_set_ssl_opts(client, opts)
    mongoc_client_t *client;
    const mongoc_ssl_opt_t *opts;
    CODE:
        mongoc_client_set_ssl_opts(client, opts);

void
client_set_stream_initiator(client, intiator, user_data)
    mongoc_client_t *client;
    mongoc_stream_initiator_t intiator;
    void *user_data;
    CODE:
        mongoc_client_set_stream_initiator(client, intiator, user_data);

void
client_set_write_concern(client, write_concern)
    mongoc_client_t *client;
    const mongoc_write_concern_t *write_concern;
    CODE:
        mongoc_client_set_write_concern(client, write_concern);

mongoc_client_session_t *
client_start_session(client, opts, error)
    mongoc_client_t *client;
    mongoc_session_opt_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_start_session(client, opts, error);
    OUTPUT:
        RETVAL

bool
client_write_command_with_opts(client, db_name, command, opts, reply ,error)
    mongoc_client_t *client;
    const char *db_name;
    const bson_t *command;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_client_write_command_with_opts(client, db_name, command, opts, reply, error);
    OUTPUT:
        RETVAL

bool
handshake_data_append(driver_name, driver_version, platform)
    const char *driver_name;
    const char *driver_version;
    const char *platform;
    CODE:
        RETVAL = mongoc_handshake_data_append(driver_name, driver_version, platform);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
collection_aggregate(collection, flags, pipeline, opts, read_prefs)
    mongoc_collection_t *collection;
    int flags;
    SV *pipeline;
    SV *opts;
    SV *read_prefs;
    CODE:
        mongoc_query_flags_t flag_value = (mongoc_query_flags_t) flags;
        const bson_t *bson_pipeline = (const bson_t *) SvIV(SvRV(pipeline));
        const bson_t *bson_opts = (const bson_t *) SvIV(SvRV(opts));
        const mongoc_read_prefs_t *read_prefs_value = NULL;
        if (SvOK(read_prefs)) {
            read_prefs_value = (const mongoc_read_prefs_t*) SvIV(SvRV(read_prefs));
        }
        RETVAL = mongoc_collection_aggregate(collection, flag_value, bson_pipeline, bson_opts, read_prefs_value);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
collection_command(collection, flags, skip, limit, batch_size, command, fields, read_prefs)
    mongoc_collection_t *collection;
    mongoc_query_flags_t flags;
    uint32_t skip;
    uint32_t limit;
    uint32_t batch_size;
    const bson_t *command;
    const bson_t *fields;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_collection_command(collection, flags, skip, limit, batch_size, command, fields, read_prefs);
    OUTPUT:
        RETVAL

bool
collection_command_simple(collection, command, read_prefs, reply, error)
    mongoc_collection_t *collection;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_command_simple(collection, command, read_prefs, reply, error);
    OUTPUT:
        RETVAL

bool
collection_command_with_opts(collection, command, read_prefs,opts, reply, error)
    mongoc_collection_t *collection;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_command_with_opts(collection, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

mongoc_collection_t *
collection_copy(collection)
    mongoc_collection_t *collection;
    CODE:
        RETVAL = mongoc_collection_copy(collection);
    OUTPUT:
        RETVAL

int64_t
collection_count_documents(collection, filter, opts, read_prefs, reply, error)
    mongoc_collection_t *collection;
    const bson_t *filter;
    const bson_t *opts;
    const mongoc_read_prefs_t *read_prefs;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_count_documents(collection, filter, opts, read_prefs, reply, error);
    OUTPUT:
        RETVAL

int64_t
collection_estimated_document_count(collection, opts, read_prefs, reply, error)
    mongoc_collection_t *collection;
    const bson_t *opts;
    const mongoc_read_prefs_t * read_prefs;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_estimated_document_count(collection, opts, read_prefs, reply, error);
    OUTPUT:
        RETVAL

int
collection_count(collection, flags, query, skip, limit, read_prefs, error)
    mongoc_collection_t *collection;
    int flags;
    SV *query;
    SV *skip;
    SV *limit;
    SV *read_prefs;
    SV *error;
    CODE:
        mongoc_query_flags_t query_flag = (mongoc_query_flags_t) flags;
        const bson_t *bson_query = (const bson_t *) SvIV(SvRV(query));
        int64_t skip_value = SvIV(skip);
        int64_t limit_value = SvIV(limit);
        const mongoc_read_prefs_t *read_prefs_value = NULL;
        if (SvOK(read_prefs)) {
            read_prefs_value = (const mongoc_read_prefs_t*) SvIV(SvRV(read_prefs));
        }
        bson_error_t *bson_error = NULL;
        if (SvOK(error)) {
            bson_error = (bson_error_t*) SvIV(SvRV(error));
        }
        int64_t output = mongoc_collection_count(collection, query_flag, bson_query, skip_value, limit_value, read_prefs_value, bson_error);
        RETVAL = (int) output;
    OUTPUT:
        RETVAL

int64_t
collection_count_with_opts(collection, flags, query,skip, limit, opts, read_prefs, error)
    mongoc_collection_t *collection;
    mongoc_query_flags_t flags;
    const bson_t *query;
    int64_t skip;
    int64_t limit;
    const bson_t *opts;
    const mongoc_read_prefs_t *read_prefs;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_count_with_opts(collection, flags, query, skip, limit, opts, read_prefs, error);
    OUTPUT:
        RETVAL

mongoc_bulk_operation_t *
collection_create_bulk_operation(collection, ordered, write_concern)
    mongoc_collection_t *collection;
    bool ordered;
    const mongoc_write_concern_t *write_concern;
    CODE:
        RETVAL = mongoc_collection_create_bulk_operation(collection, ordered, write_concern);
    OUTPUT:
        RETVAL

mongoc_bulk_operation_t *
collection_create_bulk_operation_with_opts(collection, opts)
    mongoc_collection_t *collection;
    const bson_t *opts;
    CODE:
        RETVAL = mongoc_collection_create_bulk_operation_with_opts(collection, opts);
    OUTPUT:
        RETVAL

bool
collection_create_index(collection, keys, opt, error)
    mongoc_collection_t *collection;
    const bson_t *keys;
    const mongoc_index_opt_t *opt;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_create_index(collection, keys, opt, error);
    OUTPUT:
        RETVAL

bool
collection_create_index_with_opts(collection, keys, index_opts, command_opts, reply, error)
    mongoc_collection_t *collection;
    const bson_t *keys;
    const mongoc_index_opt_t *index_opts;
    const bson_t *command_opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_create_index_with_opts(collection, keys, index_opts, command_opts, reply, error);
    OUTPUT:
        RETVAL

mongoc_index_model_t *
index_model_new(keys, opts)
    const bson_t *keys;
    const bson_t *opts;
    CODE:
        RETVAL = mongoc_index_model_new(keys, opts);
    OUTPUT:
        RETVAL

void
index_model_destroy(model)
    mongoc_index_model_t *model;
    CODE:
        mongoc_index_model_destroy(model);

lib/Pongo/Client.xs view on Meta::CPAN

        RETVAL

void
collection_destroy(collection)
    mongoc_collection_t *collection;
    CODE:
    mongoc_collection_destroy(collection);

bool
collection_drop(collection, error)
    mongoc_collection_t *collection;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_drop(collection, error);
    OUTPUT:
        RETVAL

bool
collection_drop_index(collection, index_name, error)
    mongoc_collection_t *collection;
    const char *index_name;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_drop_index(collection, index_name, error);
    OUTPUT:
        RETVAL

bool
colletion_drop_index_with_opts(collection, index_name, opts, error)
    mongoc_collection_t *collection;
    const char *index_name;
    const bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_drop_index_with_opts(collection, index_name, opts, error);
    OUTPUT:
        RETVAL

bool
collection_drop_with_opts(collection, opts, error)
    mongoc_collection_t *collection;
    bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_drop_with_opts(collection, opts, error);
    OUTPUT:
        RETVAL

bool
collection_ensure_index(collection, keys, opt, error)
    mongoc_collection_t *collection;
    const bson_t *keys;
    const mongoc_index_opt_t  *opt;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_ensure_index(collection, keys, opt, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
collection_find(collection, flags, skip, limit, batch_size, query, fields, read_prefs)
    mongoc_collection_t *collection;
    int flags;
    SV *skip;
    SV *limit;
    SV *batch_size;
    SV *query;
    SV *fields;
    SV *read_prefs;
    CODE:
        mongoc_query_flags_t flag_value = (mongoc_query_flags_t)flags;
        uint32_t skip_value = SvUV(skip);
        uint32_t limit_value = SvUV(limit);
        uint32_t batch_size_value = SvUV(batch_size);
        const bson_t *bson_query = NULL;
        if (SvOK(query)) {
            bson_query = (const bson_t *) SvIV(SvRV(query));  // Convert to BSON pointer
        } else {
            warn("Query is invalid or undef");
        }
        const bson_t *bson_fields = NULL;
        if (SvOK(fields)) {
            bson_fields = (const bson_t *) SvIV(SvRV(fields));  // Convert to BSON pointer
        } else {
            warn("Fields are invalid or undef");
        }
        const mongoc_read_prefs_t *read_prefs_value = NULL;
        if (SvOK(read_prefs)) {
            read_prefs_value = (const mongoc_read_prefs_t *) SvIV(SvRV(read_prefs)); // Dereference read_prefs
        }
        RETVAL = mongoc_collection_find(collection, flag_value, skip_value, limit_value, batch_size_value, bson_query, bson_fields, read_prefs_value);
    OUTPUT:
        RETVAL

bool
collection_find_and_modify(collection, query, sort, update, fields, _remove, upsert, _new, reply, error)
    mongoc_collection_t *collection;
    const bson_t *query;
    const bson_t *sort;
    const bson_t *update;
    const bson_t *fields;
    bool _remove;
    bool upsert;
    bool _new;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_find_and_modify(collection, query, sort, update, fields, _remove, upsert, _new, reply, error);
    OUTPUT:
        RETVAL

bool
collection_find_and_modify_with_opts(collection, query, opts, reply, error)
    mongoc_collection_t *collection;
    const bson_t *query;
    const mongoc_find_and_modify_opts_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_find_and_modify_with_opts(collection, query, opts, reply, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
collection_find_indexes(collection, error)
    mongoc_collection_t *collection;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_find_indexes(collection, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
collection_find_indexes_with_opts(collection, opts)
    mongoc_collection_t *collection;
    const bson_t *opts;
    CODE:
        RETVAL = mongoc_collection_find_indexes_with_opts(collection, opts);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
collection_find_with_opts(collection, filter, opts, read_prefs)
    mongoc_collection_t *collection;
    const bson_t *filter;
    const bson_t *opts;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_collection_find_with_opts(collection, filter, opts, read_prefs);
    OUTPUT:
        RETVAL

const bson_t *
collection_get_last_error(collection)
    const mongoc_collection_t *collection;
    CODE:
        RETVAL = mongoc_collection_get_last_error(collection);
    OUTPUT:
        RETVAL

const char *
collection_get_name(collection)
    mongoc_collection_t *collection;
    CODE:
        RETVAL = mongoc_collection_get_name(collection);
    OUTPUT:
        RETVAL

const mongoc_read_concern_t *
collection_get_read_concern(collection)
    const mongoc_collection_t *collection;
    CODE:
        RETVAL = mongoc_collection_get_read_concern(collection);
    OUTPUT:
        RETVAL

const mongoc_read_prefs_t *
collection_get_read_prefs(collection)
    const mongoc_collection_t *collection;
    CODE:
        RETVAL = mongoc_collection_get_read_prefs(collection);
    OUTPUT:
        RETVAL

const mongoc_write_concern_t *
collection_get_write_concern(collection)
    const mongoc_collection_t *collection;
    CODE:
        RETVAL = mongoc_collection_get_write_concern(collection);
    OUTPUT:
        RETVAL

bool
collection_insert(collection, flags, document, write_concern, error)
    mongoc_collection_t *collection;
    mongoc_insert_flags_t flags;
    const bson_t *document;
    const mongoc_write_concern_t *write_concern;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_insert(collection, flags, document, write_concern, error);
    OUTPUT:
        RETVAL

bool
collection_insert_bulk(collection, flags, documents, n_documents, write_concern, error)
    mongoc_collection_t *collection;
    mongoc_insert_flags_t flags;
    const bson_t **documents;
    uint32_t n_documents;
    const mongoc_write_concern_t *write_concern;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_insert_bulk(collection, flags, documents, n_documents, write_concern, error);
    OUTPUT:
        RETVAL

bool
collection_insert_many(collection, documents, n_documents, opts, reply, error)
    mongoc_collection_t *collection;
    const bson_t **documents;
    size_t n_documents;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_insert_many(collection, documents, n_documents, opts, reply, error);
    OUTPUT:
        RETVAL

bool
collection_insert_one(collection, document, opts ,reply, error)
    mongoc_collection_t *collection;
    SV *document;
    SV *opts;
    SV *reply;
    SV *error;
    CODE:
        const bson_t *bson_document = (const bson_t *) SvIV(SvRV(document));
        const bson_t *bson_opts = (opts && SvOK(opts)) ? (const bson_t*) SvIV(SvRV(opts)) : NULL;
        bson_t *bson_reply = (reply && SvOK(reply)) ? (bson_t*) SvIV(SvRV(reply)) : NULL;
        bson_error_t *bson_error = (error && SvOK(error)) ? (bson_error_t*) SvIV(SvRV(error)) : NULL;
        RETVAL = mongoc_collection_insert_one(collection, bson_document, bson_opts, bson_reply, bson_error);
    OUTPUT:
        RETVAL

char *
collection_keys_to_index_string(keys)
    const bson_t *keys;
    CODE:
        RETVAL = mongoc_collection_keys_to_index_string(keys);
    OUTPUT:
        RETVAL

bool
collection_read_command_with_opts(collection, command, read_prefs, opts, reply, error)
    mongoc_collection_t *collection;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_read_command_with_opts(collection, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

bool
collection_remove(collection, flags, selector, write_concern, error)
    mongoc_collection_t *collection;
    mongoc_remove_flags_t flags;
    const bson_t *selector;
    const mongoc_write_concern_t *write_concern;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_remove(collection, flags, selector, write_concern, error);
    OUTPUT:
        RETVAL

bool
collection_rename(collection, new_db, new_name, drop_target_before_rename, error)
    mongoc_collection_t *collection;
    const char *new_db;
    const char *new_name;
    bool drop_target_before_rename;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_rename(collection, new_db, new_name, drop_target_before_rename, error);
    OUTPUT:
        RETVAL

bool
collection_rename_with_opts(collection, new_db, new_name, drop_target_before_rename, opts, error)
    mongoc_collection_t *collection;
    const char *new_db;
    const char *new_name;
    bool drop_target_before_rename;
    const bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_rename_with_opts(collection, new_db, new_name, drop_target_before_rename, opts, error);
    OUTPUT:
        RETVAL

bool
collection_replace_one(collection, selector, replacement, opts, reply, error)
    mongoc_collection_t *collection;
    const bson_t *selector;
    const bson_t *replacement;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_replace_one(collection, selector, replacement, opts, reply, error);
    OUTPUT:
        RETVAL

bool
collection_save(collection, document, write_concern, error)
    mongoc_collection_t *collection;
    const bson_t *document;
    const mongoc_write_concern_t *write_concern;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_save(collection, document, write_concern, error);
    OUTPUT:
        RETVAL

void
collection_set_read_concern(collection, read_concern)
    mongoc_collection_t *collection;
    const mongoc_read_concern_t *read_concern;
    CODE:
        mongoc_collection_set_read_concern(collection, read_concern);

void
collection_set_read_prefs(collection, read_prefs)
    mongoc_collection_t *collection;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        mongoc_collection_set_read_prefs(collection, read_prefs);

void
collection_set_write_concern(collection, write_concern)
    mongoc_collection_t *collection;
    const mongoc_write_concern_t *write_concern;
    CODE:
        mongoc_collection_set_write_concern(collection, write_concern);

bool
collection_stats(collection, options, reply, error)
    mongoc_collection_t *collection;
    const bson_t *options;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_stats(collection, options, reply, error);
    OUTPUT:
        RETVAL

bool
collection_update(collection, flags, selector, update, write_concern, error)
    mongoc_collection_t *collection;
    mongoc_update_flags_t flags;
    const bson_t *selector;
    const bson_t *update;
    const mongoc_write_concern_t *write_concern;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_update(collection, flags, selector, update, write_concern, error);
    OUTPUT:
        RETVAL

bool
collection_update_one(collection, selector, update, opts, reply, error)
    mongoc_collection_t *collection;
    SV *selector;
    SV *update;
    SV *opts;
    SV *reply;
    SV *error;
    CODE:
        const bson_t *bson_selector = (const bson_t*) SvIV(SvRV(selector));
        const bson_t *bson_update = (const bson_t*) SvIV(SvRV(update));
        const bson_t *bson_opts = (opts && SvOK(opts)) ? (const bson_t*) SvIV(SvRV(opts)) : NULL;
        bson_t *bson_reply = (reply && SvOK(reply)) ? (bson_t*) SvIV(SvRV(reply)) : NULL;
        bson_error_t *bson_error = (error && SvOK(error)) ? (bson_error_t*) SvIV(SvRV(error)) : NULL;
        RETVAL = mongoc_collection_update_one(collection, bson_selector, bson_update, bson_opts, bson_reply, bson_error);
    OUTPUT:
        RETVAL

bool
collection_update_many(collection, selector, update, opts, reply, error)
    mongoc_collection_t *collection;
    const bson_t *selector;
    const bson_t *update;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_collection_update_many(collection, selector, update, opts, reply, error);

lib/Pongo/Client.xs view on Meta::CPAN

            }
        }
    OUTPUT:
        RETVAL

void
cursor_set_batch_size(cursor, batch_size)
    mongoc_cursor_t *cursor;
    uint32_t batch_size;
    CODE:
        mongoc_cursor_set_batch_size(cursor, batch_size);

bool
cursor_set_hint(cursor, server_id)
    mongoc_cursor_t *cursor;
    uint32_t server_id;
    CODE:
        RETVAL = mongoc_cursor_set_hint(cursor, server_id);
    OUTPUT:
        RETVAL

bool
cursor_set_server_id(cursor, server_id)
    mongoc_cursor_t *cursor;
    uint32_t server_id;
    CODE:
        RETVAL = mongoc_cursor_set_server_id(cursor, server_id);
    OUTPUT:
        RETVAL

bool
cursor_set_limit(cursor, limit)
    mongoc_cursor_t *cursor;
    int64_t limit;
    CODE:
        RETVAL = mongoc_cursor_set_limit(cursor, limit);
    OUTPUT:
        RETVAL

void
cursor_set_max_await_time_ms(cursor, max_await_time_ms)
    mongoc_cursor_t *cursor;
    uint32_t max_await_time_ms;
    CODE:
        mongoc_cursor_set_max_await_time_ms(cursor, max_await_time_ms);

bool
database_add_user(database, username, password, roles, custom_data, error)
    mongoc_database_t *database;
    const char *username;
    const char *password;
    const bson_t *roles;
    const bson_t *custom_data;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_add_user(database, username, password, roles, custom_data, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
database_aggregate(database, pipeline, opts, read_prefs)
    mongoc_database_t *database;
    const bson_t *pipeline;
    const bson_t *opts;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_database_aggregate(database, pipeline, opts, read_prefs);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
database_command(database, flags, skip, limit, batch_size, command, fields, read_prefs)
    mongoc_database_t *database;
    mongoc_query_flags_t flags;
    uint32_t skip;
    uint32_t limit;
    uint32_t batch_size;
    const bson_t *command;
    const bson_t *fields;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_database_command(database, flags, skip, limit, batch_size, command, fields, read_prefs);
    OUTPUT:
        RETVAL

bool
database_command_simple(database, command, read_prefs, reply, error)
    mongoc_database_t *database;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_command_simple(database, command, read_prefs, reply, error);
    OUTPUT:
        RETVAL

bool
database_command_with_opts(database, command, read_prefs, opts, reply, error)
    mongoc_database_t *database;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_command_with_opts(database, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

mongoc_database_t *
database_copy(database)
    mongoc_database_t *database;
    CODE:
        RETVAL = mongoc_database_copy(database);
    OUTPUT:
        RETVAL

mongoc_collection_t *
database_create_collection(database, name, opts, error)
    mongoc_database_t *database;
    const char *name;
    const bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_create_collection(database, name, opts, error);
    OUTPUT:
        RETVAL

void
database_destroy(database)
    mongoc_database_t *database;
    CODE:
        mongoc_database_destroy(database);

bool
database_drop(database, error)
    mongoc_database_t *database;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_drop(database, error);
    OUTPUT:
        RETVAL

bool
database_drop_with_opts(database, opts, error)
    mongoc_database_t *database;
    const bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_drop_with_opts(database, opts, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
database_find_collections(database, filter, error)
    mongoc_database_t *database;
    const bson_t *filter;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_find_collections(database, filter, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
database_find_collections_with_opts(database, opts)
    mongoc_database_t *database;
    const bson_t *opts;
    CODE:
        RETVAL = mongoc_database_find_collections_with_opts(database, opts);
    OUTPUT:
        RETVAL

mongoc_collection_t *
database_get_collection(database, name)
    mongoc_database_t *database;
    const char *name;
    CODE:
        RETVAL = mongoc_database_get_collection(database, name);
    OUTPUT:
        RETVAL

char **
database_get_collection_names(database, error)
    mongoc_database_t *database;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_get_collection_names(database, error);
    OUTPUT:
        RETVAL

char **
database_get_collection_names_with_opts(database, opts, error)
    mongoc_database_t *database;
    const bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_get_collection_names_with_opts(database, opts, error);
    OUTPUT:
        RETVAL

const char *
database_get_name(database)
    mongoc_database_t *database;
    CODE:
        RETVAL = mongoc_database_get_name(database);
    OUTPUT:
        RETVAL

const mongoc_read_concern_t *
database_get_read_concern(database)
    const mongoc_database_t *database;
    CODE:
        RETVAL = mongoc_database_get_read_concern(database);
    OUTPUT:
        RETVAL

const mongoc_read_prefs_t *
database_get_read_prefs(database)
    const mongoc_database_t *database;
    CODE:
        RETVAL = mongoc_database_get_read_prefs(database);
    OUTPUT:
        RETVAL

const mongoc_write_concern_t *
database_get_write_concern(database)
    const mongoc_database_t *database;
    CODE:
        RETVAL = mongoc_database_get_write_concern(database);
    OUTPUT:
        RETVAL

bool
database_has_collection(database, name, error)
    mongoc_database_t *database;
    const char *name;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_has_collection(database, name, error);
    OUTPUT:
        RETVAL

bool
database_read_command_with_opts(database, command, read_prefs, opts, reply, error)
    mongoc_database_t *database;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_read_command_with_opts(database, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

bool
database_read_write_command_with_opts(database, command, read_prefs, opts, reply, error)
    mongoc_database_t *database;
    const bson_t *command;
    const mongoc_read_prefs_t *read_prefs;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_read_write_command_with_opts(database, command, read_prefs, opts, reply, error);
    OUTPUT:
        RETVAL

bool
database_remove_all_users(database, error)
    mongoc_database_t *database;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_remove_all_users(database, error);
    OUTPUT:
        RETVAL

bool
database_remove_user(database, username, error)
    mongoc_database_t *database;
    const char *username;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_remove_user(database, username, error);
    OUTPUT:
        RETVAL

void
database_set_read_concern(database, read_concern)
    mongoc_database_t *database;
    const mongoc_read_concern_t *read_concern;
    CODE:
        mongoc_database_set_read_concern(database, read_concern);

void
database_set_read_prefs(database, read_prefs)
    mongoc_database_t *database;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        mongoc_database_set_read_prefs(database, read_prefs);

void
database_set_write_concern(database, write_concern)
    mongoc_database_t *database;
    const mongoc_write_concern_t *write_concern;
    CODE:
        mongoc_database_set_write_concern(database, write_concern);

bool
database_write_command_with_opts(database, command, opts, reply, error)
    mongoc_database_t *database;
    const bson_t *command;
    const bson_t *opts;
    bson_t *reply;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_database_write_command_with_opts(database, command, opts, reply, error);
    OUTPUT:
        RETVAL

bool
find_and_modify_opts_append(opts, extra)
    mongoc_find_and_modify_opts_t *opts;
    const bson_t *extra;
    CODE:
        RETVAL = mongoc_find_and_modify_opts_append(opts, extra);
    OUTPUT:
        RETVAL

void
find_and_modify_opts_destroy(find_and_modify_opts)
    mongoc_find_and_modify_opts_t *find_and_modify_opts;
    CODE:
        mongoc_find_and_modify_opts_destroy(find_and_modify_opts);

bool
find_and_modify_opts_get_bypass_document_validation(opts)
    const mongoc_find_and_modify_opts_t *opts;
    CODE:
        RETVAL = mongoc_find_and_modify_opts_get_bypass_document_validation(opts);
    OUTPUT:
        RETVAL

void
find_and_modify_opts_get_fields(opts, fields)
    const mongoc_find_and_modify_opts_t *opts;
    bson_t *fields;
    CODE:
        mongoc_find_and_modify_opts_get_fields(opts, fields);

mongoc_find_and_modify_flags_t
find_and_modify_opts_get_flags(opts)
    const mongoc_find_and_modify_opts_t *opts;
    CODE:
        RETVAL = mongoc_find_and_modify_opts_get_flags(opts);
    OUTPUT:
        RETVAL

uint32_t
find_and_modify_opts_get_max_time_ms(opts)

lib/Pongo/Client.xs view on Meta::CPAN

    uint32_t timeout_msec;
    CODE:
        RETVAL = mongoc_gridfs_file_writev(file, iov, iovcnt, timeout_msec);
    OUTPUT:
        RETVAL

mongoc_stream_t *
stream_gridfs_new(file)
    mongoc_gridfs_file_t *file;
    CODE:
        RETVAL = mongoc_stream_gridfs_new(file);
    OUTPUT:
        RETVAL

bool
gridfs_bucket_abort_upload(stream)
    mongoc_stream_t *stream;
    CODE:
        RETVAL = mongoc_gridfs_bucket_abort_upload(stream);
    OUTPUT:
        RETVAL

bool
gridfs_bucket_delete_by_id(bucket, file_id, error)
    mongoc_gridfs_bucket_t *bucket;
    const bson_value_t *file_id;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_delete_by_id(bucket, file_id, error);
    OUTPUT:
        RETVAL

void
gridfs_bucket_destroy(bucket)
    mongoc_gridfs_bucket_t *bucket;
    CODE:
        mongoc_gridfs_bucket_destroy(bucket);

bool
gridfs_bucket_download_to_stream(bucket, file_id, destination, error)
    mongoc_gridfs_bucket_t *bucket;
    const bson_value_t *file_id;
    mongoc_stream_t *destination;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_download_to_stream(bucket, file_id, destination, error);
    OUTPUT:
        RETVAL

mongoc_cursor_t *
gridfs_bucket_find(bucket, filter, opts)
    mongoc_gridfs_bucket_t *bucket;
    const bson_t *filter;
    const bson_t *opts;
    CODE:
        RETVAL = mongoc_gridfs_bucket_find(bucket, filter, opts);
    OUTPUT:
        RETVAL

mongoc_gridfs_bucket_t *
gridfs_bucket_new(db, opts, read_prefs, error)
    mongoc_database_t *db;
    const bson_t *opts;
    const mongoc_read_prefs_t *read_prefs;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_new(db, opts, read_prefs, error);
    OUTPUT:
        RETVAL

mongoc_stream_t *
gridfs_bucket_open_download_stream(bucket, file_id, error)
    mongoc_gridfs_bucket_t *bucket;
    const bson_value_t *file_id;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_open_download_stream(bucket, file_id, error);
    OUTPUT:
        RETVAL

mongoc_stream_t *
gridfs_bucket_open_upload_stream(bucket, filename, opts, file_id, error)
    mongoc_gridfs_bucket_t *bucket;
    const char *filename;
    const bson_t *opts;
    bson_value_t *file_id;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_open_upload_stream(bucket, filename, opts, file_id, error);
    OUTPUT:
        RETVAL

mongoc_stream_t *
gridfs_bucket_open_upload_stream_with_id(bucket, file_id, filename, opts, error)
    mongoc_gridfs_bucket_t *bucket;
    const bson_value_t *file_id;
    const char *filename;
    const bson_t *opts;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_open_upload_stream_with_id(bucket, file_id, filename, opts, error);
    OUTPUT:
        RETVAL

bool
gridfs_bucket_stream_error(stream, error)
    mongoc_stream_t *stream;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_stream_error(stream, error);
    OUTPUT:
        RETVAL

bool
gridfs_bucket_upload_from_stream(bucket, filename, source, opts, file_id, error)
    mongoc_gridfs_bucket_t *bucket;
    const char *filename;
    mongoc_stream_t *source;
    const bson_t *opts;
    bson_value_t *file_id;
    bson_error_t *error;
    CODE:
        RETVAL = mongoc_gridfs_bucket_upload_from_stream(bucket, filename, source, opts, file_id, error);
    OUTPUT:
        RETVAL

bool

lib/Pongo/Client.xs view on Meta::CPAN

        RETVAL = mongoc_rand_status();
    OUTPUT:
        RETVAL

bool
read_concern_append(read_concern, opts)
    mongoc_read_concern_t *read_concern;
    bson_t *opts;
    CODE:
        RETVAL = mongoc_read_concern_append(read_concern, opts);
    OUTPUT:
        RETVAL

mongoc_read_concern_t *
read_concern_copy(read_concern)
    const mongoc_read_concern_t *read_concern;
    CODE:
        RETVAL = mongoc_read_concern_copy(read_concern);
    OUTPUT:
        RETVAL

void
read_concern_destroy(read_concern)
    mongoc_read_concern_t *read_concern;
    CODE:
        mongoc_read_concern_destroy(read_concern);

const char *
read_concern_get_level(read_concern)
    const mongoc_read_concern_t *read_concern;
    CODE:
        RETVAL = mongoc_read_concern_get_level(read_concern);
    OUTPUT:
        RETVAL

bool
read_concern_is_default(read_concern)
    mongoc_read_concern_t *read_concern;
    CODE:
        RETVAL = mongoc_read_concern_is_default(read_concern);
    OUTPUT:
        RETVAL

mongoc_read_concern_t *
read_concern_new(void)
    CODE:
        RETVAL = mongoc_read_concern_new();
    OUTPUT:
        RETVAL

bool
read_concern_set_level(read_concern, level)
    mongoc_read_concern_t *read_concern;
    const char *level;
    CODE:
        RETVAL = mongoc_read_concern_set_level(read_concern, level);
    OUTPUT:
        RETVAL

void
read_prefs_add_tag(read_prefs, tag)
    mongoc_read_prefs_t *read_prefs;
    const bson_t *tag;
    CODE:
        mongoc_read_prefs_add_tag(read_prefs, tag);

mongoc_read_prefs_t *
read_prefs_copy(read_prefs)
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_read_prefs_copy(read_prefs);
    OUTPUT:
        RETVAL

void
read_prefs_destroy(read_prefs)
    mongoc_read_prefs_t *read_prefs;
    CODE:
        mongoc_read_prefs_destroy(read_prefs);

const bson_t *
read_prefs_get_hedge(read_prefs)
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_read_prefs_get_hedge(read_prefs);
    OUTPUT:
        RETVAL

int64_t
read_prefs_get_max_staleness_seconds(read_prefs)
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_read_prefs_get_max_staleness_seconds(read_prefs);
    OUTPUT:
        RETVAL

mongoc_read_mode_t
read_prefs_get_mode(read_prefs)
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_read_prefs_get_mode(read_prefs);
    OUTPUT:
        RETVAL

const bson_t *
read_prefs_get_tags(read_prefs)
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_read_prefs_get_tags(read_prefs);
    OUTPUT:
        RETVAL

bool
read_prefs_is_valid(read_prefs)
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        RETVAL = mongoc_read_prefs_is_valid(read_prefs);
    OUTPUT:
        RETVAL

mongoc_read_prefs_t *
read_prefs_new(read_mode)
    mongoc_read_mode_t read_mode;
    CODE:
        RETVAL = mongoc_read_prefs_new(read_mode);
    OUTPUT:
        RETVAL

void
read_prefs_set_hedge(read_prefs, hedge)
    mongoc_read_prefs_t *read_prefs;
    const bson_t *hedge;
    CODE:
        mongoc_read_prefs_set_hedge(read_prefs, hedge);

void
read_prefs_set_max_staleness_seconds(read_prefs, max_staleness_seconds)
    mongoc_read_prefs_t *read_prefs;
    int64_t max_staleness_seconds;
    CODE:
        mongoc_read_prefs_set_max_staleness_seconds(read_prefs, max_staleness_seconds);

void
read_prefs_set_mode(read_prefs, mode)
    mongoc_read_prefs_t *read_prefs;
    mongoc_read_mode_t mode;
    CODE:
        mongoc_read_prefs_set_mode(read_prefs, mode);

void
read_prefs_set_tags(read_prefs, tags)
    mongoc_read_prefs_t *read_prefs;
    const bson_t *tags;
    CODE:
        mongoc_read_prefs_set_tags(read_prefs, tags);

mongoc_server_api_t *
server_api_copy(api)
    const mongoc_server_api_t *api;
    CODE:
        RETVAL = mongoc_server_api_copy(api);
    OUTPUT:
        RETVAL

void
server_api_deprecation_errors(api, deprecation_errors)
    mongoc_server_api_t *api;
    bool deprecation_errors;
    CODE:
        mongoc_server_api_deprecation_errors(api, deprecation_errors);

void
server_api_destroy(api)
    mongoc_server_api_t *api;
    CODE:
        mongoc_server_api_destroy(api);

const mongoc_optional_t *
server_api_get_deprecation_errors(api)
    const mongoc_server_api_t *api;
    CODE:
        RETVAL = mongoc_server_api_get_deprecation_errors(api);
    OUTPUT:
        RETVAL

const mongoc_optional_t *
server_api_get_strict(api)
    const mongoc_server_api_t *api;
    CODE:
        RETVAL = mongoc_server_api_get_strict(api);
    OUTPUT:
        RETVAL

mongoc_server_api_version_t
server_api_get_version(api)
    const mongoc_server_api_t *api;
    CODE:
        RETVAL = mongoc_server_api_get_version(api);
    OUTPUT:
        RETVAL

mongoc_server_api_t *
server_api_new(version)
    mongoc_server_api_version_t version;
    CODE:
        RETVAL = mongoc_server_api_new(version);
    OUTPUT:
        RETVAL

void
server_api_strict(api, strict)
    mongoc_server_api_t *api;
    bool strict;
    CODE:
        mongoc_server_api_strict(api, strict);

lib/Pongo/Client.xs view on Meta::CPAN

    mongoc_socklen_t optlen;
    CODE:
        RETVAL = mongoc_stream_setsockopt(stream, level, optname, optval, optlen);
    OUTPUT:
        RETVAL

bool
stream_should_retry(stream)
    mongoc_stream_t *stream;
    CODE:
        RETVAL = mongoc_stream_should_retry(stream);
    OUTPUT:
        RETVAL

bool
stream_timed_out(stream)
    mongoc_stream_t *stream;
    CODE:
        RETVAL = mongoc_stream_timed_out(stream);
    OUTPUT:
        RETVAL

ssize_t
stream_write(stream, buf, count, timeout_msec)
    mongoc_stream_t *stream;
    void *buf;
    size_t count;
    int32_t timeout_msec;
    CODE:
        RETVAL = mongoc_stream_write(stream, buf, count, timeout_msec);
    OUTPUT:
        RETVAL

ssize_t
stream_writev(stream, iov, iovcnt, timeout_msec)
    mongoc_stream_t *stream;
    mongoc_iovec_t *iov;
    size_t iovcnt;
    int32_t timeout_msec;
    CODE:
        RETVAL = mongoc_stream_writev(stream, iov, iovcnt, timeout_msec);
    OUTPUT:
        RETVAL

void
topology_description_destroy(description)
    mongoc_topology_description_t *description;
    CODE:
        mongoc_topology_description_destroy(description);

mongoc_server_description_t **
topology_description_get_servers(td, n)
    const mongoc_topology_description_t *td;
    size_t *n;
    CODE:
        RETVAL = mongoc_topology_description_get_servers(td, n);
    OUTPUT:
        RETVAL

bool
topology_description_has_readable_server(td, prefs)
    const mongoc_topology_description_t *td;
    const mongoc_read_prefs_t *prefs;
    CODE:
        RETVAL = mongoc_topology_description_has_readable_server(td, prefs);
    OUTPUT:
        RETVAL

bool
topology_description_has_writable_server(td)
    const mongoc_topology_description_t *td;
    CODE:
        RETVAL = mongoc_topology_description_has_writable_server(td);
    OUTPUT:
        RETVAL

mongoc_topology_description_t *
topology_description_new_copy(description)
    const mongoc_topology_description_t *description;
    CODE:
        RETVAL = mongoc_topology_description_new_copy(description);
    OUTPUT:
        RETVAL

const char *
topology_description_type(td)
    const mongoc_topology_description_t *td;
    CODE:
        RETVAL = mongoc_topology_description_type(td);
    OUTPUT:
        RETVAL

void
transaction_opts_set_read_concern(opts, read_concern)
    mongoc_transaction_opt_t *opts;
    const mongoc_read_concern_t *read_concern;
    CODE:
        mongoc_transaction_opts_set_read_concern(opts, read_concern);

void
transaction_opts_set_write_concern(opts, write_concern)
    mongoc_transaction_opt_t *opts;
    const mongoc_write_concern_t *write_concern;
    CODE:
        mongoc_transaction_opts_set_write_concern(opts, write_concern);

void
transaction_opts_set_read_prefs(opts, read_prefs)
    mongoc_transaction_opt_t *opts;
    const mongoc_read_prefs_t *read_prefs;
    CODE:
        mongoc_transaction_opts_set_read_prefs(opts, read_prefs);

mongoc_transaction_opt_t *
transaction_opts_new()
    CODE:
        RETVAL = mongoc_transaction_opts_new();
    OUTPUT:
        RETVAL

const mongoc_read_concern_t *
transaction_opts_get_read_concern(opts)
    const mongoc_transaction_opt_t *opts;
    CODE:
        RETVAL = mongoc_transaction_opts_get_read_concern(opts);
    OUTPUT:
        RETVAL

const mongoc_write_concern_t *
transaction_opts_get_write_concern(opts)
    const mongoc_transaction_opt_t *opts;
    CODE:
        RETVAL = mongoc_transaction_opts_get_write_concern(opts);
    OUTPUT:
        RETVAL

const mongoc_read_prefs_t *
transaction_opts_get_read_prefs(opts)
    const mongoc_transaction_opt_t *opts;
    CODE:
        RETVAL = mongoc_transaction_opts_get_read_prefs(opts);
    OUTPUT:
        RETVAL

int64_t
transaction_opts_get_max_commit_time_ms(opts)
    const mongoc_transaction_opt_t *opts;
    CODE:
        RETVAL = mongoc_transaction_opts_get_max_commit_time_ms(opts);
    OUTPUT:
        RETVAL

void
transaction_opts_set_max_commit_time_ms(opts, max_commit_time_ms)
    mongoc_transaction_opt_t *opts;
    int64_t max_commit_time_ms;
    CODE:
        mongoc_transaction_opts_set_max_commit_time_ms(opts, max_commit_time_ms);

mongoc_transaction_opt_t *
transaction_opts_clone(opts)
    const mongoc_transaction_opt_t *opts;
    CODE:
        RETVAL = mongoc_transaction_opts_clone(opts);
    OUTPUT:
        RETVAL

void
transaction_opts_destroy(opts)
    mongoc_transaction_opt_t *opts;
    CODE:
        mongoc_transaction_opts_destroy(opts);

const mongoc_index_opt_geo_t *
index_opt_geo_get_default()
    CODE:
        RETVAL = mongoc_index_opt_geo_get_default();
    OUTPUT:
        RETVAL

void
index_opt_geo_init(opt)
    mongoc_index_opt_geo_t *opt;
    CODE:
        mongoc_index_opt_geo_init(opt);

const mongoc_index_opt_t *
index_opt_get_default()
    CODE:
        RETVAL = mongoc_index_opt_get_default();
    OUTPUT:
        RETVAL

void
index_opt_init(opt)
    mongoc_index_opt_t *opt;
    CODE:
        mongoc_index_opt_init(opt);

bool
write_concern_append(write_concern, command)

lib/Pongo/Client.xs view on Meta::CPAN

    CODE:
        RETVAL = mongoc_uri_get_option_as_bool(uri, option, fallback);
    OUTPUT:
        RETVAL

int32_t
uri_get_option_as_int32(uri, option, fallback)
    const mongoc_uri_t *uri;
    const char *option;
    int32_t fallback;
    CODE:
        RETVAL = mongoc_uri_get_option_as_int32(uri, option, fallback);
    OUTPUT:
        RETVAL

int64_t
uri_get_option_as_int64(uri, option, fallback)
    const mongoc_uri_t *uri;
    const char *option;
    int64_t fallback;
    CODE:
        RETVAL = mongoc_uri_get_option_as_int64(uri, option, fallback);
    OUTPUT:
        RETVAL

const char *
uri_get_option_as_utf8(uri, option, fallback)
    const mongoc_uri_t *uri;
    const char *option;
    const char *fallback;
    CODE:
        RETVAL = mongoc_uri_get_option_as_utf8(uri, option, fallback);
    OUTPUT:
        RETVAL

const bson_t *
uri_get_options(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_options(uri);
    OUTPUT:
        RETVAL

const char *
uri_get_password(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_password(uri);
    OUTPUT:
        RETVAL

const mongoc_read_concern_t *
uri_get_read_concern(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_read_concern(uri);
    OUTPUT:
        RETVAL

const bson_t *
uri_get_read_prefs(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_read_prefs(uri);
    OUTPUT:
        RETVAL

const char *
uri_get_replica_set(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_replica_set(uri);
    OUTPUT:
        RETVAL

const char *
uri_get_server_monitoring_mode(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_server_monitoring_mode(uri);
    OUTPUT:
        RETVAL

const char *
uri_get_service(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_service(uri);
    OUTPUT:
        RETVAL

bool
uri_get_ssl(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_ssl(uri);
    OUTPUT:
        RETVAL

const char *
uri_get_string(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_string(uri);
    OUTPUT:
        RETVAL

const char *
uri_get_srv_hostname(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_srv_hostname(uri);
    OUTPUT:
        RETVAL

const char *
uri_get_srv_service_name(uri)
    const mongoc_uri_t *uri;
    CODE:
        RETVAL = mongoc_uri_get_srv_service_name(uri);
    OUTPUT:
        RETVAL

bool

lib/Pongo/Client.xs view on Meta::CPAN

    OUTPUT:
        RETVAL

bool
uri_set_option_as_bool(uri, option, value)
    const mongoc_uri_t *uri;
    const char *option;
    bool value;
    CODE:
        RETVAL = mongoc_uri_set_option_as_bool(uri, option, value);
    OUTPUT:
        RETVAL

bool
uri_set_option_as_int32(uri, option, value)
    const mongoc_uri_t *uri;
    const char *option;
    int32_t value;
    CODE:
        RETVAL = mongoc_uri_set_option_as_int32(uri, option, value);
    OUTPUT:
        RETVAL

bool
uri_set_option_as_int64(uri, option, value)
    const mongoc_uri_t *uri;
    const char *option;
    int64_t value;
    CODE:
        RETVAL = mongoc_uri_set_option_as_int64(uri, option, value);
    OUTPUT:
        RETVAL

bool
uri_set_option_as_utf8(uri, option, value)
    const mongoc_uri_t *uri;
    const char *option;
    const char *value;
    CODE:
        RETVAL = mongoc_uri_set_option_as_utf8(uri, option, value);
    OUTPUT:
        RETVAL

bool
uri_set_password(uri, password)
    mongoc_uri_t *uri;
    const char *password;
    CODE:
        RETVAL = mongoc_uri_set_password(uri, password);
    OUTPUT:
        RETVAL

void
uri_set_read_concern(uri, rc)
    mongoc_uri_t *uri;
    const mongoc_read_concern_t *rc;
    CODE:
        mongoc_uri_set_read_concern(uri, rc);

void
uri_set_read_prefs(uri, prefs)
    mongoc_uri_t *uri;
    const mongoc_read_prefs_t *prefs;
    CODE:
        mongoc_uri_set_read_prefs_t(uri, prefs);

bool
uri_set_server_monitoring_mode(uri, value)
    mongoc_uri_t *uri;
    const char *value;
    CODE:
        RETVAL = mongoc_uri_set_server_monitoring_mode(uri, value);
    OUTPUT:
        RETVAL

bool
uri_set_username(uri, username)
    mongoc_uri_t *uri;
    const char *username;
    CODE:
        RETVAL = mongoc_uri_set_username(uri, username);
    OUTPUT:
        RETVAL

void
uri_set_write_concern(uri, wc)
    mongoc_uri_t *uri;
    const mongoc_write_concern_t *wc;
    CODE:
        mongoc_uri_set_write_concern(uri, wc);

char *
uri_unescape(escaped_string)
    const char *escaped_string;
    CODE:
        RETVAL = mongoc_uri_unescape(escaped_string);
    OUTPUT:
        RETVAL

( run in 2.650 seconds using v1.01-cache-2.11-cpan-8f98c5d2c55 )