Pongo

 view release on metacpan or  search on metacpan

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

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

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

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

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

        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:

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

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

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

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);

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

        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

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

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);

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

    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;

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

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

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

        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

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

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;

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

        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)

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

    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

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

        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

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

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:

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

        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)

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

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);

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

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

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

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

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

        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)

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

        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

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

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

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

        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