mirror of
https://github.com/macintoshplus/mongo-php-driver.git
synced 2026-04-02 14:22:19 +02:00
294 lines
9.8 KiB
PHP
294 lines
9.8 KiB
PHP
<?php
|
|
|
|
namespace MongoDB;
|
|
|
|
/**
|
|
* Manager abstracts a cluster of Server objects (i.e. socket connections).
|
|
*
|
|
* Typically, users will connect to a cluster using a URI, and the Manager will
|
|
* perform tasks such as replica set discovery and create the necessary Server
|
|
* objects. That said, it is also possible to create a Manager with an arbitrary
|
|
* collection of Server objects using the static factory method (this can be
|
|
* useful for testing or administration).
|
|
*
|
|
* Operation methods do not take socket-level options (e.g. socketTimeoutMS).
|
|
* Those options should be specified during construction.
|
|
*/
|
|
final class Manager
|
|
{
|
|
/**
|
|
* Constructs a new Manager
|
|
*
|
|
* @param string $uri Connection URI
|
|
* @param array $options Connection options (e.g. auth, socket timeouts)
|
|
* @param array $driverOptions Driver options (e.g. stream contexts)
|
|
*/
|
|
public function __construct($uri, array $options = array(), array $driverOptions = array())
|
|
{
|
|
// Parse DSN and options and create Server objects
|
|
/*** CEF ***/
|
|
/*
|
|
void ***ctx = NULL;
|
|
TSRMLS_SET_CTX(ctx);
|
|
*/
|
|
/*** CEF ***/
|
|
/*** CIMPL ***/
|
|
/*
|
|
intern->client = mongoc_client_new(uri);
|
|
if (!intern->client) {
|
|
phongo_throw_exception(PHONGO_ERROR_RUNETIME, "Failed to parse MongoDB URI" TSRMLS_CC);
|
|
return;
|
|
}
|
|
mongoc_client_set_stream_initiator(intern->client, phongo_stream_initiator, ctx);
|
|
*/
|
|
/*** CIMPL ***/
|
|
}
|
|
|
|
/**
|
|
* Creates new Manager from a list of servers
|
|
*
|
|
* @param Server[] $servers
|
|
* @return Manager
|
|
*/
|
|
static public function createFromServers(array $servers)
|
|
{
|
|
/* Instantiate a new Manager instance with the provided Servers
|
|
*
|
|
* Should this method take $driverOptions as a second parameter? The
|
|
* Servers would already be constructed, so stream context options
|
|
* would not apply; however, we may want to take other options, such as
|
|
* event callbacks, down the line.
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Execute a command
|
|
*
|
|
* @param string $db
|
|
* @param Command $command
|
|
* @param ReadPreference $readPreference
|
|
* @return CommandResult
|
|
*/
|
|
public function executeCommand($db, Command $command, ReadPreference $readPreference = null)
|
|
{
|
|
/* Select server based on (1) command requirements and (2) read
|
|
* preference and invoke Server::executeCommand().
|
|
*
|
|
* Read preferences should be injected into the command document if
|
|
* necessary (e.g. mongos).
|
|
*
|
|
* Rely on libmongoc for server selection and read preference injection.
|
|
*
|
|
* Throw exception if no candidate server is found. Throw a special
|
|
* exception the command requirement and read preferences logically
|
|
* conflict (e.g. mapReduce with output collection and secondary RP).
|
|
*/
|
|
/*** CEF ***/
|
|
/*
|
|
php_phongo_command_t *cmd;
|
|
*/
|
|
/*** CEF ***/
|
|
/*** CIMPL ***/
|
|
/*
|
|
cmd = (php_phongo_command_t *)zend_object_store_get_object(command TSRMLS_CC);
|
|
phongo_execute_command(intern->client, db, cmd->bson, phongo_read_preference_from_zval(readPreference TSRMLS_CC), return_value, return_value_used TSRMLS_CC);
|
|
*/
|
|
/*** CIMPL ***/
|
|
}
|
|
|
|
/**
|
|
* Execute a Query
|
|
*
|
|
* @param string $namespace
|
|
* @param Query $zquery
|
|
* @param ReadPreference $readPreference
|
|
* @return QueryResult
|
|
*/
|
|
public function executeQuery($namespace, Query $zquery, ReadPreference $readPreference = null)
|
|
{
|
|
/* Select server based on read preference and invoke
|
|
* Server::executeQuery().
|
|
*
|
|
* Read preferences should be injected into the query document if
|
|
* necessary (e.g. mongos).
|
|
*
|
|
* Rely on libmongoc for server selection and read preference injection.
|
|
*
|
|
* Throw exception if no candidate server is found.
|
|
*/
|
|
/*** CIMPL ***/
|
|
/*
|
|
phongo_execute_query(intern->client, namespace, phongo_query_from_zval(zquery TSRMLS_CC), phongo_read_preference_from_zval(readPreference TSRMLS_CC), return_value, return_value_used TSRMLS_CC);
|
|
*/
|
|
/*** CIMPL ***/
|
|
}
|
|
|
|
/**
|
|
* Executes a write operation batch (e.g. insert, update, delete)
|
|
*
|
|
* @param string $namespace
|
|
* @param WriteBatch $zbatch
|
|
* @param array $writeOptions Ordering and write concern options (default: {"ordered": true, "w": 1})
|
|
* @return WriteResult
|
|
*/
|
|
public function executeWrite($namespace, WriteBatch $zbatch, array $writeOptions = null)
|
|
{
|
|
/* Select writeable server and invoke Server::executeQuery().
|
|
*
|
|
* Write options are optional, and will be merged into the default,
|
|
* which is {"ordered": true, "w": 1}.
|
|
*
|
|
* On error, we should consider throwing:
|
|
*
|
|
* - NoCandidateException: no writeable server was found
|
|
* - WriteException: write failed; a WriteResult should be included.
|
|
* - ConnectionException: low-level socket error
|
|
*
|
|
* If a WriteException is thrown, its WriteResult may contain multiple
|
|
* write errors and write concern errors.
|
|
*/
|
|
/*** CEF ***/
|
|
/*
|
|
php_phongo_writebatch_t *batch;
|
|
*/
|
|
/*** CEF ***/
|
|
/*** CIMPL ***/
|
|
/*
|
|
batch = (php_phongo_writebatch_t *)zend_object_store_get_object(zbatch TSRMLS_CC);
|
|
phongo_execute_write(intern->client, namespace, batch->batch, 0, return_value, return_value_used TSRMLS_CC);
|
|
*/
|
|
/*** CIMPL ***/
|
|
}
|
|
|
|
/**
|
|
* Convenience method for single insert operation.
|
|
*
|
|
* @param string $namespace
|
|
* @param array|object $document Document to insert
|
|
* @param array $writeOptions Write concern options (default: {"w": 1})
|
|
* @return WriteResult
|
|
*/
|
|
public function executeInsert($namespace, $document, array $writeOptions = null)
|
|
{
|
|
/* Construct and execute a WriteBatch with a single insert operation.
|
|
*
|
|
* Write options are optional, and will be merged into the default,
|
|
* which is {"w": 1}.
|
|
*/
|
|
/*** CEF ***/
|
|
/*
|
|
bson_t *bson;
|
|
*/
|
|
/*** CEF ***/
|
|
/*** CIMPL ***/
|
|
/*
|
|
bson = bson_new();
|
|
php_phongo_bson_encode_array(bson, document TSRMLS_CC);
|
|
phongo_execute_single_insert(intern->client, namespace, bson, return_value, return_value_used TSRMLS_CC);
|
|
bson_destroy(bson);
|
|
*/
|
|
/*** CIMPL ***/
|
|
}
|
|
|
|
/**
|
|
* Convenience method for single update operation.
|
|
*
|
|
* @param string $namespace
|
|
* @param array|object $zquery Update criteria
|
|
* @param array|object $newObj Update modifier or replacement document
|
|
* @param array $updateOptions Update options (e.g. "upsert")
|
|
* @param array $writeOptions Write concern options (default: {"w": 1})
|
|
* @return WriteResult
|
|
*/
|
|
public function executeUpdate($namespace, $zquery, $newObj, array $updateOptions = null, array $writeOptions = null)
|
|
{
|
|
$updateOptions = array_merge(
|
|
array('multi' => false, 'upsert' => false),
|
|
$updateOptions
|
|
);
|
|
|
|
/* Construct and execute a WriteBatch with a single update operation.
|
|
*
|
|
* Write options are optional, and will be merged into the default,
|
|
* which is {"w": 1}.
|
|
*/
|
|
/*** CEF ***/
|
|
/*
|
|
bson_t *query;
|
|
bson_t *update;
|
|
mongoc_update_flags_t flags = MONGOC_UPDATE_NONE;
|
|
*/
|
|
/*** CEF ***/
|
|
/*** CIMPL ***/
|
|
/*
|
|
query = bson_new();
|
|
update = bson_new();
|
|
php_phongo_bson_encode_array(query, zquery TSRMLS_CC);
|
|
php_phongo_bson_encode_array(update, newObj TSRMLS_CC);
|
|
|
|
if (updateOptions && php_array_fetch_bool(updateOptions, "upsert")) {
|
|
flags |= MONGOC_UPDATE_UPSERT;
|
|
}
|
|
if (updateOptions && php_array_fetch_bool(updateOptions, "limit")) {
|
|
flags |= MONGOC_UPDATE_MULTI_UPDATE;
|
|
}
|
|
|
|
phongo_execute_single_update(intern->client, namespace, query, update, flags, return_value, return_value_used TSRMLS_CC);
|
|
bson_destroy(query);
|
|
bson_destroy(update);
|
|
*/
|
|
/*** CIMPL ***/
|
|
}
|
|
|
|
/**
|
|
* Convenience method for single delete operation.
|
|
*
|
|
* @param string $namespace
|
|
* @param array|object $query Deletion criteria
|
|
* @param array $deleteOptions Deletion options (e.g. "limit")
|
|
* @param array $writeOptions Write concern options (default: {"w": 1})
|
|
* @return WriteResult
|
|
*/
|
|
public function executeDelete($namespace, $query, array $deleteOptions = null, array $writeOptions = null)
|
|
{
|
|
/* TODO: Decide if we should default to 0 (i.e. "all"), as in 1.x, or if
|
|
* an explicit "limit" option must be required. Keeping $deleteOptions
|
|
* as an array, rather than a single integer option for "limit", seems
|
|
* wise; if the "delete" command ever takes additional options, we would
|
|
* not need to change our API.
|
|
*/
|
|
$deleteOptions = array_merge(
|
|
array('limit' => 0),
|
|
$deleteOptions
|
|
);
|
|
|
|
/* Construct and execute a WriteBatch with a single delete operation.
|
|
*
|
|
* Write options are optional, and will be merged into the default,
|
|
* which is {"w": 1}.
|
|
*/
|
|
/*** CEF ***/
|
|
/*
|
|
bson_t *bson;
|
|
mongoc_delete_flags_t flags = MONGOC_DELETE_NONE;
|
|
*/
|
|
/*** CEF ***/
|
|
/*** CIMPL ***/
|
|
/*
|
|
if (deleteOptions && php_array_fetch_bool(deleteOptions, "limit")) {
|
|
flags |= MONGOC_DELETE_SINGLE_REMOVE;
|
|
}
|
|
bson = bson_new();
|
|
php_phongo_bson_encode_array(bson, query TSRMLS_CC);
|
|
phongo_execute_single_delete(intern->client, namespace, bson, flags, return_value, return_value_used TSRMLS_CC);
|
|
bson_destroy(bson);
|
|
*/
|
|
/*** CIMPL ***/
|
|
}
|
|
}
|
|
$Manager["free"] = <<< EOF
|
|
mongoc_client_destroy(intern->client);
|
|
|
|
EOF;
|
|
$Manager["headers"][] = '"php_array.h"';
|