PageRenderTime 29ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/hphp/runtime/ext_zend_compat/mongo/ext_mongo.php

http://github.com/facebook/hiphop-php
PHP | 1451 lines | 511 code | 192 blank | 748 comment | 0 complexity | b4e9063609731f8d212e4612435aaba4 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, MIT, LGPL-2.0, Apache-2.0 
    

  1. <?hh
    2. 

  2. // generated by idl-to-hni.php
    3. 

  3. 

  4. /* A connection manager for PHP and MongoDB.  This class is used to create and
    5. 

  5.  * manage connections. A typical use is: Example #1 MongoClient basic usage
    6. 

  6.  * See MongoClient::__construct() and the section on connecting for more
    7. 

  7.  * information about creating connections.
    8. 

  8.  */
    9. 

  9. <<__NativeData("ZendCompat")>>
    10. 

  10. class MongoClient {
    11. 

  11.   public bool $connected = false;
    12. 

  12.   public mixed $status;
    13. 

  13.   protected mixed $server;
    14. 

  14.   protected mixed $persistent;
    15. 

  15. 

  16.   /* The MongoClient::close() method forcefully closes a connection to the
    17. 

  17.    * database, even if persistent connections are being used. You should never
    18. 

  18.    * have to do this under normal circumstances.
    19. 

  19.    */
    20. 

  20.   <<__Native("ZendCompat")>>
    21. 

  21.   public function close(mixed $connection): mixed;
    22. 

  22. 

  23.   <<__Native("ZendCompat")>>
    24. 

  24.   public function connect(): mixed;
    25. 

  25. 

  26.   /* If no parameters are passed, this connects to "localhost:27017" (or
    27. 

  27.    * whatever was specified in php.ini for mongo.default_host and
    28. 

  28.    * mongo.default_port).  server should have the form:    The connection string
    29. 

  29.    * always starts with mongodb://, to indicate it is a connection string in
    30. 

  30.    * this form. username and password are specified, the constructor will
    31. 

  31.    * attempt to authenticate the connection with the database before returning.
    32. 

  32.    * Username and password are optional and must be followed by an @, if
    33. 

  33.    * specified.  At least one host must be given (port optional, always
    34. 

  34.    * defaulting to 27017) and as many hosts as desired may be connected to. Host
    35. 

  35.    * names are comma-separated and the constructor will return successfully if
    36. 

  36.    * it connected to at least one host. If it could not connect to any of the
    37. 

  37.    * hosts, it will throw a MongoConnectionException. Please see the Replica
    38. 

  38.    * Sets section for information on how to connect to Replica Sets.  If you
    39. 

  39.    * specified a username and password, you may specify a database to
    40. 

  40.    * authenticate with. If db is not specified, "admin" will be used.  An
    41. 

  41.    * optional query string may be used to specify extra options. The same
    42. 

  42.    * options are supported through the options array as well, and are therefore
    43. 

  43.    * redescribed there. See the examples below on how to set those options.  One
    44. 

  44.    * part of the options governs how the driver reads from secondary nodes in a
    45. 

  45.    * replica set environment. Extra information on how these read preferences
    46. 

  46.    * work is available as well through the read preferences documentation page.
    47. 

  47.    */
    48. 

  48.   <<__Native("ZendCompat")>>
    49. 

  49.   public function __construct(mixed $server,
    50. 

  50.                               mixed $options);
    51. 

  51. 

  52.   <<__Native("ZendCompat")>>
    53. 

  53.   public function dropDB(mixed $db): mixed;
    54. 

  54. 

  55.   /* This is the cleanest way of getting a database. If the database name has
    56. 

  56.    * any special characters, MongoClient::selectDB() will need to be used;
    57. 

  57.    * however, this should be sufficient for most cases.
    58. 

  58.    */
    59. 

  59.   <<__Native("ZendCompat")>>
    60. 

  60.   public function __get(mixed $dbname): mixed;
    61. 

  61. 

  62.   /* Returns an array of all open connections, and information about each of the
    63. 

  63.    * servers
    64. 

  64.    */
    65. 

  65.   <<__Native("ZendCompat")>>
    66. 

  66.   public static function getConnections(): mixed;
    67. 

  67. 

  68.   /* This method is only useful with a connection to a replica set. It returns
    69. 

  69.    * the status of all of the hosts in the set. Without a replica set, it will
    70. 

  70.    * just return an array with one element containing the host that you are
    71. 

  71.    * connected to.  See the query section of this manual for information on
    72. 

  72.    * distributing reads to secondaries.
    73. 

  73.    */
    74. 

  74.   <<__Native("ZendCompat")>>
    75. 

  75.   public function getHosts(): mixed;
    76. 

  76. 

  77.   <<__Native("ZendCompat")>>
    78. 

  78.   public function getReadPreference(): mixed;
    79. 

  79. 

  80.   <<__Native("ZendCompat")>>
    81. 

  81.   public function listDBs(): mixed;
    82. 

  82. 

  83.   <<__Native("ZendCompat")>>
    84. 

  84.   public function selectCollection(mixed $db,
    85. 

  85.                                    mixed $collection): mixed;
    86. 

  86. 

  87.   <<__Native("ZendCompat")>>
    88. 

  88.   public function selectDB(mixed $name): mixed;
    89. 

  89. 

  90.   <<__Native("ZendCompat")>>
    91. 

  91.   public function setReadPreference(mixed $read_preference,
    92. 

  92.                                     mixed $tags): mixed;
    93. 

  93. 

  94.   <<__Native("ZendCompat")>>
    95. 

  95.   public function __toString(): mixed;
    96. 

  96. }
    97. 

  97. 

  98. /* Instances of this class are used to interact with a database. To get a
    99. 

  99.  * database: Example #1 Selecting a database  Database names can use almost
    100. 

  100.  * any character in the ASCII range. However, they cannot contain " ", "." or
    101. 

  101.  * be the empty string. The name "system" is also reserved.  A few unusual,
    102. 

  102.  * but valid, database names: "null", "[x,y]", "3", "\"", "/".  Unlike
    103. 

  103.  * collection names, database names may contain "$".
    104. 

  104.  */
    105. 

  105. <<__NativeData("ZendCompat")>>
    106. 

  106. class MongoDB {
    107. 

  107.   public int $w = 1;
    108. 

  108.   public int $wtimeout = 10000;
    109. 

  109. 

  110.   /* This method causes its connection to be authenticated. If authentication is
    111. 

  111.    * enabled for the database server (it's not, by default), you need to log in
    112. 

  112.    * before the database will allow you to do anything.  In general, you should
    113. 

  113.    * use the authenticate built into MongoClient::__construct() in preference to
    114. 

  114.    * this method. If you authenticate on connection and the connection drops and
    115. 

  115.    * reconnects during your session, you'll be reauthenticated. If you manually
    116. 

  116.    * authenticated using this method and the connection drops, you'll have to
    117. 

  117.    * call this method again once you're reconnected.  This method is identical
    118. 

  118.    * to running:    Once a connection has been authenticated, it can only be
    119. 

  119.    * un-authenticated by using the "logout" database command:
    120. 

  120.    */
    121. 

  121.   <<__Native("ZendCompat")>>
    122. 

  122.   public function authenticate(mixed $username,
    123. 

  123.                                mixed $password): mixed;
    124. 

  124. 

  125.   /* Almost everything that is not a CRUD operation can be done with a database
    126. 

  126.    * command. Need to know the database version? There's a command for that.
    127. 

  127.    * Need to do aggregation? There's a command for that. Need to turn up
    128. 

  128.    * logging? You get the idea.  This method is identical to:
    129. 

  129.    */
    130. 

  130.   <<__Native("ZendCompat")>>
    131. 

  131.   public function command(mixed $command,
    132. 

  132.                           mixed $options): mixed;
    133. 

  133. 

  134.   /* This method is not meant to be called directly. The preferred way to create
    135. 

  135.    * an instance of MongoDB is through MongoClient::__get() or
    136. 

  136.    * MongoClient::selectDB().  If you're ignoring the previous paragraph and
    137. 

  137.    * want to call it directly you can do so:    But don't. Isn't this much
    138. 

  138.    * nicer:
    139. 

  139.    */
    140. 

  140.   <<__Native("ZendCompat")>>
    141. 

  141.   public function __construct(mixed $conn,
    142. 

  142.                               mixed $name);
    143. 

  143. 

  144.   /* This method is used to create capped collections and other collections
    145. 

  145.    * requiring special options. It is identical to running:  See
    146. 

  146.    * MongoDB::command() for more information about database commands.
    147. 

  147.    */
    148. 

  148.   <<__Native("ZendCompat")>>
    149. 

  149.   public function createCollection(mixed $name,
    150. 

  150.                                    mixed $options,
    151. 

  151.                                    mixed $capped,
    152. 

  152.                                    mixed $size,
    153. 

  153.                                    mixed $max): mixed;
    154. 

  154. 

  155.   /* This method is a flexible interface for creating database references (see
    156. 

  156.    * MongoDBRef).
    157. 

  157.    */
    158. 

  158.   <<__Native("ZendCompat")>>
    159. 

  159.   public function createDBRef(mixed $collection,
    160. 

  160.                               mixed $document_or_id): mixed;
    161. 

  161. 

  162.   /* This drops the database currently being used.  This is identical to
    163. 

  163.    * running:
    164. 

  164.    */
    165. 

  165.   <<__Native("ZendCompat")>>
    166. 

  166.   public function drop(): mixed;
    167. 

  167. 

  168.   <<__Native("ZendCompat")>>
    169. 

  169.   public function dropCollection(mixed $coll): mixed;
    170. 

  170. 

  171.   /* The Mongo database server runs a JavaScript engine. This method allows you
    172. 

  172.    * to run arbitrary JavaScript on the database. This can be useful if you want
    173. 

  173.    * touch a number of collections lightly, or process some results on the
    174. 

  174.    * database side to reduce the amount that has to be sent to the client.
    175. 

  175.    * Running JavaScript in the database takes a write lock, meaning it blocks
    176. 

  176.    * other operations. Make sure you consider this before running a long script.
    177. 

  177.    *  This is a wrapper for a database command. This method is basically:
    178. 

  178.    * MongoDB implies a return statement if you have a single statement on a
    179. 

  179.    * single line. This can cause some unintuitive behavior. For example, this
    180. 

  180.    * returns "foo":    However, these return NULL:    To avoid surprising
    181. 

  181.    * behavior, it is best not to depend on MongoDB to decide what to return, but
    182. 

  182.    * to explicitly state a return value. In the examples above, we can change
    183. 

  183.    * them to:    Now the first statement will return "foo" and the second
    184. 

  184.    * statement will return a count of the "foo" collection.
    185. 

  185.    */
    186. 

  186.   <<__Native("ZendCompat")>>
    187. 

  187.   public function execute(mixed $code,
    188. 

  188.                           mixed $args): mixed;
    189. 

  189. 

  190.   /* This method is not very useful for normal MongoDB use. It forces a database
    191. 

  191.    * error to occur. This means that MongoDB::lastError() will return a generic
    192. 

  192.    * database error after running this command.  This command is identical to
    193. 

  193.    * running:
    194. 

  194.    */
    195. 

  195.   <<__Native("ZendCompat")>>
    196. 

  196.   public function forceError(): mixed;
    197. 

  197. 

  198.   /* This is the easiest way of getting a collection from a database object. If
    199. 

  199.    * a collection name contains strange characters, you may have to use
    200. 

  200.    * MongoDB::selectCollection() instead.
    201. 

  201.    */
    202. 

  202.   <<__Native("ZendCompat")>>
    203. 

  203.   public function __get(mixed $name): mixed;
    204. 

  204. 

  205.   /* Returns an array of all the collection names for the given database.
    206. 

  206.    */
    207. 

  207.   <<__Native("ZendCompat")>>
    208. 

  208.   public function getCollectionNames(mixed $includeSystemCollections): mixed;
    209. 

  209. 

  210.   <<__Native("ZendCompat")>>
    211. 

  211.   public function getDBRef(mixed $ref): mixed;
    212. 

  212. 

  213.   <<__Native("ZendCompat")>>
    214. 

  214.   public function getGridFS(mixed $prefix): mixed;
    215. 

  215. 

  216.   /* This returns the current database profiling level.  The database profiler
    217. 

  217.    * tracks query execution times. If you turn it on (say, using
    218. 

  218.    * MongoDB::setProfilingLevel() or the shell), you can see how many queries
    219. 

  219.    * took longer than a given number of milliseconds or the timing for all
    220. 

  220.    * queries.  Note that profiling slows down queries, so it is better to use in
    221. 

  221.    * development or testing than in a time-sensitive application.  This function
    222. 

  222.    * is equivalent to running:
    223. 

  223.    */
    224. 

  224.   <<__Native("ZendCompat")>>
    225. 

  225.   public function getProfilingLevel(): mixed;
    226. 

  226. 

  227.   <<__Native("ZendCompat")>>
    228. 

  228.   public function getReadPreference(): mixed;
    229. 

  229. 

  230.   /* See the query section of this manual for information on distributing reads
    231. 

  231.    * to secondaries.
    232. 

  232.    */
    233. 

  233.   <<__Native("ZendCompat")>>
    234. 

  234.   public function getSlaveOkay(): mixed;
    235. 

  235. 

  236.   /* This method is equivalent to:
    237. 

  237.    */
    238. 

  238.   <<__Native("ZendCompat")>>
    239. 

  239.   public function lastError(): mixed;
    240. 

  240. 

  241.   /* Gets a list of all the collections in the database and returns them as an
    242. 

  242.    * array of MongoCollection objects.
    243. 

  243.    */
    244. 

  244.   <<__Native("ZendCompat")>>
    245. 

  245.   public function listCollections(mixed $includeSystemCollections): mixed;
    246. 

  246. 

  247.   /* MongoDB::lastError() is usually preferred to this. This method returns the
    248. 

  248.    * last database error that occurred and how many operations ago it occurred.
    249. 

  249.    * It is mostly deprecated.
    250. 

  250.    */
    251. 

  251.   <<__Native("ZendCompat")>>
    252. 

  252.   public function prevError(): mixed;
    253. 

  253. 

  254.   /* This creates a fresh copy of all database data. It will remove any corrupt
    255. 

  255.    * data and compact and large stretches of free space it finds. This is a very
    256. 

  256.    * slow operation on a large database.  This is usually run from the shell or
    257. 

  257.    * the command line, not the driver.  It is equivalent to the function:
    258. 

  258.    */
    259. 

  259.   <<__Native("ZendCompat")>>
    260. 

  260.   public function repair(mixed $preserve_cloned_files,
    261. 

  261.                          mixed $backup_original_files): mixed;
    262. 

  262. 

  263.   /* This method is not used in normal operations. It resets the database error
    264. 

  264.    * tracker (which can be incremented with MongoDB::forceError(), also not
    265. 

  265.    * normally used).  It is equivalent to running:
    266. 

  266.    */
    267. 

  267.   <<__Native("ZendCompat")>>
    268. 

  268.   public function resetError(): mixed;
    269. 

  269. 

  270.   <<__Native("ZendCompat")>>
    271. 

  271.   public function selectCollection(mixed $name): mixed;
    272. 

  272. 

  273.   /* This changes the current database profiling level.  This function is
    274. 

  274.    * equivalent to running:    The options for level are 0 (off), 1 (queries >
    275. 

  275.    * 100ms), and 2 (all queries). If you would like to profile queries that take
    276. 

  276.    * longer than another time period, use the database command and pass it a
    277. 

  277.    * second option, the number of milliseconds. For example, to profile all
    278. 

  278.    * queries that take longer than one second, run:    Profiled queries will
    279. 

  279.    * appear in the system.profile collection of this database.
    280. 

  280.    */
    281. 

  281.   <<__Native("ZendCompat")>>
    282. 

  282.   public function setProfilingLevel(mixed $level): mixed;
    283. 

  283. 

  284.   <<__Native("ZendCompat")>>
    285. 

  285.   public function setReadPreference(mixed $read_preference,
    286. 

  286.                                     mixed $tags): mixed;
    287. 

  287. 

  288.   /* See the query section of this manual for information on distributing reads
    289. 

  289.    * to secondaries.
    290. 

  290.    */
    291. 

  291.   <<__Native("ZendCompat")>>
    292. 

  292.   public function setSlaveOkay(mixed $ok): mixed;
    293. 

  293. 

  294.   <<__Native("ZendCompat")>>
    295. 

  295.   public function __toString(): mixed;
    296. 

  296. }
    297. 

  297. 

  298. /* Representations a database collection.  Collection names can use any
    299. 

  299.  * character in the ASCII set. Some valid collection names are "", "...", "my
    300. 

  300.  * collection", and "*&#@".  User-defined collection names cannot contain the
    301. 

  301.  * $ symbol. There are certain system collections which use a $ in their names
    302. 

  302.  * (e.g., local.oplog.$main), but it is a reserved character. If you attempt
    303. 

  303.  * to create and use a collection with a $ in the name, MongoDB will assert.
    304. 

  304.  */
    305. 

  305. <<__NativeData("ZendCompat")>>
    306. 

  306. class MongoCollection {
    307. 

  307.   public int $w = 1;
    308. 

  308.   public int $wtimeout = 10000;
    309. 

  309. 

  310. 

  311.   /* The MongoDB aggregation framework provides a means to calculate aggregated
    312. 

  312.    * values without having to use MapReduce. While MapReduce is powerful, it is
    313. 

  313.    * often more difficult than necessary for many simple aggregation tasks, such
    314. 

  314.    * as totaling or averaging field values.  This method accepts either a
    315. 

  315.    * variable amount of pipeline operators, or a single array of operators
    316. 

  316.    * constituting the pipeline.
    317. 

  317.    */
    318. 

  318.   <<__Native("ZendCompat")>>
    319. 

  319.   public function aggregate(mixed $pipeline,
    320. 

  320.                             mixed $op): mixed;
    321. 

  321. 

  322.   <<__Native("ZendCompat")>>
    323. 

  323.   public function batchInsert(mixed $a,
    324. 

  324.                               mixed $options = array()): mixed;
    325. 

  325. 

  326.   <<__Native("ZendCompat")>>
    327. 

  327.   public function __construct(mixed $db,
    328. 

  328.                               mixed $name);
    329. 

  329. 

  330.   <<__Native("ZendCompat")>>
    331. 

  331.   public function count(mixed $query,
    332. 

  332.                         mixed $limit,
    333. 

  333.                         mixed $skip): mixed;
    334. 

  334. 

  335.   <<__Native("ZendCompat")>>
    336. 

  336.   public function createDBRef(mixed $document_or_id): mixed;
    337. 

  337. 

  338.   /* This method is identical to:    Each index, when created, is given a unique
    339. 

  339.    * name. This is generally user-set (with MongoCollection::ensureIndex()'s
    340. 

  340.    * "name" option) or generated by the driver from a combination of key names
    341. 

  341.    * and directions. This name is then used by MongoCollection::deleteIndex() to
    342. 

  342.    * remove the function.  Unfortunately, the MongoCollection::ensureIndex()
    343. 

  343.    * generates slightly different names than the shell and, due to backwards
    344. 

  344.    * compatibility issues, MongoCollection::deleteIndex() cannot delete
    345. 

  345.    * custom-named indexes as well. Thus, the best way to delete indexes created
    346. 

  346.    * in the shell or with custom names is to directly call the deleteIndexes
    347. 

  347.    * database command.  Thus, if you named an index "superfast query", you could
    348. 

  348.    * only delete it with the PHP driver by running:    To find what an index is
    349. 

  349.    * named, you can query the system.indexes collection of a database and look
    350. 

  350.    * for the name field.
    351. 

  351.    */
    352. 

  352.   <<__Native("ZendCompat")>>
    353. 

  353.   public function deleteIndex(mixed $keys): mixed;
    354. 

  354. 

  355.   <<__Native("ZendCompat")>>
    356. 

  356.   public function deleteIndexes(): mixed;
    357. 

  357. 

  358.   /* The distinct command returns a list of distinct values for the given key
    359. 

  359.    * across a collection.
    360. 

  360.    */
    361. 

  361.   <<__Native("ZendCompat")>>
    362. 

  362.   public function distinct(mixed $key,
    363. 

  363.                            mixed $query): mixed;
    364. 

  364. 

  365.   /* Drops this collection and deletes its indices.
    366. 

  366.    */
    367. 

  367.   <<__Native("ZendCompat")>>
    368. 

  368.   public function drop(): mixed;
    369. 

  369. 

  370.   /* This method creates an index on the collection and the specified fields.
    371. 

  371.    * The key specification can either be just a single field name as string, or
    372. 

  372.    * an array containing one or more field names with their sort direction.
    373. 

  373.    */
    374. 

  374.   <<__Native("ZendCompat")>>
    375. 

  375.   public function ensureIndex(mixed $keys,
    376. 

  376.                               mixed $options): mixed;
    377. 

  377. 

  378.   <<__Native("ZendCompat")>>
    379. 

  379.   public function find(mixed $query,
    380. 

  380.                        mixed $fields): mixed;
    381. 

  381. 

  382.   /* The findAndModify command atomically modifies and returns a single
    383. 

  383.    * document. By default, the returned document does not include the
    384. 

  384.    * modifications made on the update. To return the document with the
    385. 

  385.    * modifications made on the update, use the new option.
    386. 

  386.    */
    387. 

  387.   <<__Native("ZendCompat")>>
    388. 

  388.   public function findAndModify(mixed $query,
    389. 

  389.                                 mixed $update,
    390. 

  390.                                 mixed $fields,
    391. 

  391.                                 mixed $options): mixed;
    392. 

  392. 

  393.   /* As opposed to MongoCollection::find(), this method will return only the
    394. 

  394.    * first result from the result set, and not a MongoCursor that can be
    395. 

  395.    * iterated over.
    396. 

  396.    */
    397. 

  397.   <<__Native("ZendCompat")>>
    398. 

  398.   public function findOne(mixed $query,
    399. 

  399.                           mixed $fields): mixed;
    400. 

  400. 

  401.   /* A concise syntax for getting a collection with a dot-separated name. If a
    402. 

  402.    * collection name contains strange characters, you may have to use
    403. 

  403.    * MongoDB::selectCollection() instead.
    404. 

  404.    */
    405. 

  405.   <<__Native("ZendCompat")>>
    406. 

  406.   public function __get(mixed $name): mixed;
    407. 

  407. 

  408.   <<__Native("ZendCompat")>>
    409. 

  409.   public function getDBRef(mixed $ref): mixed;
    410. 

  410. 

  411.   <<__Native("ZendCompat")>>
    412. 

  412.   public function getIndexInfo(): mixed;
    413. 

  413. 

  414.   <<__Native("ZendCompat")>>
    415. 

  415.   public function getName(): mixed;
    416. 

  416. 

  417.   <<__Native("ZendCompat")>>
    418. 

  418.   public function getReadPreference(): mixed;
    419. 

  419. 

  420.   /* See the query section of this manual for information on distributing reads
    421. 

  421.    * to secondaries.
    422. 

  422.    */
    423. 

  423.   <<__Native("ZendCompat")>>
    424. 

  424.   public function getSlaveOkay(): mixed;
    425. 

  425. 

  426.   <<__Native("ZendCompat")>>
    427. 

  427.   public function group(mixed $keys,
    428. 

  428.                         mixed $initial,
    429. 

  429.                         mixed $reduce,
    430. 

  430.                         mixed $options): mixed;
    431. 

  431. 

  432.   /* All strings sent to the database must be UTF-8. If a string is not UTF-8, a
    433. 

  433.    * MongoException will be thrown. To insert (or query for) a non-UTF-8 string,
    434. 

  434.    * use MongoBinData.
    435. 

  435.    */
    436. 

  436.   <<__Native("ZendCompat")>>
    437. 

  437.   public function insert(mixed $a,
    438. 

  438.                          mixed $options): mixed;
    439. 

  439. 

  440.   <<__Native("ZendCompat")>>
    441. 

  441.   public function remove(mixed $criteria,
    442. 

  442.                          mixed $options): mixed;
    443. 

  443. 

  444.   /* If the object is from the database, update the existing database object,
    445. 

  445.    * otherwise insert this object.
    446. 

  446.    */
    447. 

  447.   <<__Native("ZendCompat")>>
    448. 

  448.   public function save(mixed $a,
    449. 

  449.                        mixed $options): mixed;
    450. 

  450. 

  451.   <<__Native("ZendCompat")>>
    452. 

  452.   public function setReadPreference(mixed $read_preference,
    453. 

  453.                                     mixed $tags): mixed;
    454. 

  454. 

  455.   /* See the query section of this manual for information on distributing reads
    456. 

  456.    * to secondaries.
    457. 

  457.    */
    458. 

  458.   <<__Native("ZendCompat")>>
    459. 

  459.   public function setSlaveOkay(mixed $ok): mixed;
    460. 

  460. 

  461.   <<__Native("ZendCompat")>>
    462. 

  462.   protected static function toIndexString(mixed $keys): mixed;
    463. 

  463. 

  464.   <<__Native("ZendCompat")>>
    465. 

  465.   public function __toString(): mixed;
    466. 

  466. 

  467.   <<__Native("ZendCompat")>>
    468. 

  468.   public function update(mixed $criteria,
    469. 

  469.                          mixed $new_object,
    470. 

  470.                          mixed $options): mixed;
    471. 

  471. 

  472.   <<__Native("ZendCompat")>>
    473. 

  473.   public function validate(mixed $scan_data): mixed;
    474. 

  474. }
    475. 

  475. 

  476. /* A cursor is used to iterate through the results of a database query. For
    477. 

  477.  * example, to query the database and see all results, you could do: Example
    478. 

  478.  * #1 MongoCursor basic usage    You don't generally create cursors using the
    479. 

  479.  * MongoCursor constructor, you get a new cursor by calling
    480. 

  480.  * MongoCollection::find() (as shown above).  Suppose that, in the example
    481. 

  481.  * above, $collection was a 50GB collection. We certainly wouldn't want to
    482. 

  482.  * load that into memory all at once, which is what a cursor is for: allowing
    483. 

  483.  * the client to access the collection in dribs and drabs.  If we have a large
    484. 

  484.  * result set, we can iterate through it, loading a few megabytes of results
    485. 

  485.  * into memory at a time. For example, we could do: Example #2 Iterating over
    486. 

  486.  * MongoCursor  This will go through each document in the collection, loading
    487. 

  487.  * and garbage collecting documents as needed.  Note that this means that a
    488. 

  488.  * cursor does not "contain" the database results, it just manages them. Thus,
    489. 

  489.  * if you print a cursor (with, say, var_dump() or print_r()), you'll just get
    490. 

  490.  * the cursor object, not your documents. To get the documents themselves, you
    491. 

  491.  * can use one of the methods shown above.
    492. 

  492.  */
    493. 

  493. <<__NativeData("ZendCompat")>>
    494. 

  494. class MongoCursor {
    495. 

  495.   public static bool $slaveOkay = false;
    496. 

  496.   public static int $timeout = 30000;
    497. 

  497. 

  498.   /* This is an advanced function and should not be used unless you know what
    499. 

  499.    * you're doing.  A query can optionally be nested in a "query" field if other
    500. 

  500.    * options, such as a sort or hint, are given. For instance, adding a sort
    501. 

  501.    * causes the query to become a subfield of a bigger query object, like:
    502. 

  502.    * This method is for adding a top-level field to a query. It makes the query
    503. 

  503.    * a subobject (if it isn't already) and adds the key/value pair of your
    504. 

  504.    * choosing to the top level. Warning  It cannot be used to add extra criteria
    505. 

  505.    * to a query on the fly. For instance, this will not work:  This does not
    506. 

  506.    * query for a user named "joe" with an age of 20.
    507. 

  507.    */
    508. 

  508.   <<__Native("ZendCompat")>>
    509. 

  509.   public function addOption(mixed $key,
    510. 

  510.                             mixed $value): mixed;
    511. 

  511. 

  512.   /* This method is to be used with tailable cursors. If we are at the end of
    513. 

  513.    * the data, block for a while rather than returning no data. After a timeout
    514. 

  514.    * period, we do return as normal.
    515. 

  515.    */
    516. 

  516.   <<__Native("ZendCompat")>>
    517. 

  517.   public function awaitData(mixed $wait): mixed;
    518. 

  518. 

  519.   /* A cursor typically fetches a batch of result objects and store them
    520. 

  520.    * locally. This method sets the batchSize value to configure the amount of
    521. 

  521.    * documents retrieved from the server in one data packet. However, it will
    522. 

  522.    * never return more documents than fit in the max batch size limit (usually
    523. 

  523.    * 4MB).
    524. 

  524.    */
    525. 

  525.   <<__Native("ZendCompat")>>
    526. 

  526.   public function batchSize(mixed $batchSize): mixed;
    527. 

  527. 

  528.   <<__Native("ZendCompat")>>
    529. 

  529.   public function __construct(mixed $connection,
    530. 

  530.                               mixed $ns,
    531. 

  531.                               mixed $query,
    532. 

  532.                               mixed $fields);
    533. 

  533. 

  534.   /* This method does not affect the state of the cursor: if you haven't queried
    535. 

  535.    * yet, you can still apply limits, skips, etc. If you have started iterating
    536. 

  536.    * through results, it will not move the current position of the cursor. If
    537. 

  537.    * you have exhasted the cursor, it will not reset it.
    538. 

  538.    */
    539. 

  539.   <<__Native("ZendCompat")>>
    540. 

  540.   public function count(mixed $foundOnly): mixed;
    541. 

  541. 

  542.   /* This returns NULL until MongoCursor::next() is called.
    543. 

  543.    */
    544. 

  544.   <<__Native("ZendCompat")>>
    545. 

  545.   public function current(): mixed;
    546. 

  546. 

  547.   /* The database sends responses in batches of documents, up to 4MB of
    548. 

  548.    * documents per response. This method checks if the database has more batches
    549. 

  549.    * or if the result set has been exhausted.  A cursor being "dead" does not
    550. 

  550.    * mean that MongoCursor::hasNext() will return FALSE, it only means that the
    551. 

  551.    * database is done sending results to the client. The client should continue
    552. 

  552.    * iterating through results until MongoCursor::hasNext() is FALSE.
    553. 

  553.    */
    554. 

  554.   <<__Native("ZendCompat")>>
    555. 

  555.   public function dead(): mixed;
    556. 

  556. 

  557.   <<__Native("ZendCompat")>>
    558. 

  558.   public function doQuery(): mixed;
    559. 

  559. 

  560.   <<__Native("ZendCompat")>>
    561. 

  561.   public function explain(): mixed;
    562. 

  562. 

  563.   /* Fields are specified by "fieldname" : bool. TRUE indicates that a field
    564. 

  564.    * should be returned, FALSE indicates that it should not be returned. You can
    565. 

  565.    * also use 1 and 0 instead of TRUE and FALSE.  Thus, to return only the
    566. 

  566.    * "summary" field, one could say:    To return all fields except the "hidden"
    567. 

  567.    * field:
    568. 

  568.    */
    569. 

  569.   <<__Native("ZendCompat")>>
    570. 

  570.   public function fields(mixed $f): mixed;
    571. 

  571. 

  572.   /* This is identical to the function:
    573. 

  573.    */
    574. 

  574.   <<__Native("ZendCompat")>>
    575. 

  575.   public function getNext(): mixed;
    576. 

  576. 

  577.   <<__Native("ZendCompat")>>
    578. 

  578.   public function getReadPreference(): mixed;
    579. 

  579. 

  580.   <<__Native("ZendCompat")>>
    581. 

  581.   public function hasNext(): mixed;
    582. 

  582. 

  583.   <<__Native("ZendCompat")>>
    584. 

  584.   public function hint(mixed $index): mixed;
    585. 

  585. 

  586.   /* After remaining idle on the server for some amount of time, cursors, by
    587. 

  587.    * default, "die." This is generally the behavior one wants. The database
    588. 

  588.    * cleans up a cursor once all of its results have been sent to the client,
    589. 

  589.    * but if the client doesn't request all of the results, the cursor will
    590. 

  590.    * languish there, taking up resources. Thus, after a few minutes, the cursor
    591. 

  591.    * "times out" and the database assumes the client has gotten everything it
    592. 

  592.    * needs and cleans up its the cursor's resources.  If, for some reason, you
    593. 

  593.    * need a cursor to hang around for a long time, you can prevent the database
    594. 

  594.    * from cleaning it up by using this method. However, if you make a cursor
    595. 

  595.    * immortal, you need to iterate through all of its results (or at least until
    596. 

  596.    * MongoCursor::dead() returns TRUE) or the cursor will hang around the
    597. 

  597.    * database forever, taking up resources.
    598. 

  598.    */
    599. 

  599.   <<__Native("ZendCompat")>>
    600. 

  600.   public function immortal(mixed $liveForever): mixed;
    601. 

  601. 

  602. /* This can be called before or after the query.
    603. 

  603.  */
    604. 

  604.   <<__Native("ZendCompat")>>
    605. 

  605.   public function info(): mixed;
    606. 

  606. 

  607.   <<__Native("ZendCompat")>>
    608. 

  608.   public function key(): mixed;
    609. 

  609. 

  610.   <<__Native("ZendCompat")>>
    611. 

  611.   public function limit(mixed $num): mixed;
    612. 

  612. 

  613.   <<__Native("ZendCompat")>>
    614. 

  614.   public function next(): mixed;
    615. 

  615. 

  616.   /* This option allows mongos to send partial query results if a shard is
    617. 

  617.    * unreachable. This is only applicable when running a sharded MongoDB cluster
    618. 

  618.    * and connecting to a mongos.  If a shard goes down and a query needs to be
    619. 

  619.    * sent to that shard, mongos will return the results (if any) from shards it
    620. 

  620.    * already contacted, then an error message that it could not reach the shard
    621. 

  621.    * (a MongoCursorException in PHP). If you would like to get whatever results
    622. 

  622.    * mongos can provide and no exception, you can use this method. Note that
    623. 

  623.    * this means that you won't have an indication that a shard is down in your
    624. 

  624.    * query response.  This has no effect on the query if all shards are
    625. 

  625.    * reachable. This flag was implemented in MongoDB version 1.7.5, so will only
    626. 

  626.    * work with that version and higher.
    627. 

  627.    */
    628. 

  628.   <<__Native("ZendCompat")>>
    629. 

  629.   public function partial(mixed $okay): mixed;
    630. 

  630. 

  631.   <<__Native("ZendCompat")>>
    632. 

  632.   public function reset(): mixed;
    633. 

  633. 

  634.   /* This is identical to the function:
    635. 

  635.    */
    636. 

  636.   <<__Native("ZendCompat")>>
    637. 

  637.   public function rewind(): mixed;
    638. 

  638. 

  639.   /* The MongoCursor class has several methods for setting flags on the query
    640. 

  640.    * object. This method is available in case the MongoDB wire protocol has
    641. 

  641.    * acquired a new flag, and the driver has not been updated with a method for
    642. 

  642.    * this new flag. In all other cases, the method should be used. See the "See
    643. 

  643.    * also" section for available methods.
    644. 

  644.    */
    645. 

  645.   <<__Native("ZendCompat")>>
    646. 

  646.   public function setFlag(mixed $flag,
    647. 

  647.                           mixed $set): mixed;
    648. 

  648. 

  649.   <<__Native("ZendCompat")>>
    650. 

  650.   public function setReadPreference(mixed $read_preference,
    651. 

  651.                                     mixed $tags): mixed;
    652. 

  652. 

  653.   <<__Native("ZendCompat")>>
    654. 

  654.   public function skip(mixed $num): mixed;
    655. 

  655. 

  656.   /* Calling this will make the driver route reads to secondaries if: You are
    657. 

  657.    * using a replica set and You created a MongoClient instance using the option
    658. 

  658.    * "replicaSet" => "setName" and There is a healthy secondary that can be
    659. 

  659.    * reached by the driver. You can check which server was used for this query
    660. 

  660.    * by calling MongoCursor::info() after running the query. It's server field
    661. 

  661.    * will show which server the query was sent to.  Note that you should use
    662. 

  662.    * this function even if you do not use the automatic routing to secondaries.
    663. 

  663.    * If you connect directly to a secondary in a replica set, you still need to
    664. 

  664.    * call this function, which basically tells the database that you are aware
    665. 

  665.    * that you might be getting older data and you're okay with that. If you do
    666. 

  666.    * not call this, you'll get "not master" errors when you try to query.  This
    667. 

  667.    * method will override the static class variable MongoCursor::$slaveOkay. It
    668. 

  668.    * will also override Mongo::setSlaveOkay(), MongoDB::setSlaveOkay() and
    669. 

  669.    * MongoCollection::setSlaveOkay().
    670. 

  670.    */
    671. 

  671.   <<__Native("ZendCompat")>>
    672. 

  672.   public function slaveOkay(mixed $okay): mixed;
    673. 

  673. 

  674.   /* Use snapshot mode for the query. Snapshot mode assures no duplicates are
    675. 

  675.    * returned, or objects missed, which were present at both the start and end
    676. 

  676.    * of the query's execution (if an object is new during the query, or deleted
    677. 

  677.    * during the query, it may or may not be returned, even with snapshot mode).
    678. 

  678.    * Note that short query responses (less than 1MB) are always effectively
    679. 

  679.    * snapshotted.  Currently, snapshot mode may not be used with sorting or
    680. 

  680.    * explicit hints.
    681. 

  681.    */
    682. 

  682.   <<__Native("ZendCompat")>>
    683. 

  683.   public function snapshot(): mixed;
    684. 

  684. 

  685.   <<__Native("ZendCompat")>>
    686. 

  686.   public function sort(mixed $fields): mixed;
    687. 

  687. 

  688.   /* Mongo has a feature known as tailable cursors which are similar to the Unix
    689. 

  689.    * "tail -f" command.  Tailable means cursor is not closed when the last data
    690. 

  690.    * is retrieved. Rather, the cursor marks the final object's position. you can
    691. 

  691.    * resume using the cursor later, from where it was located, if more data were
    692. 

  692.    * received.  Like any "latent cursor", the cursor may become invalid at some
    693. 

  693.    * point -- for example if that final object it references were deleted. Thus,
    694. 

  694.    * you should be prepared to requery if the cursor is MongoCursor::dead().
    695. 

  695.    */
    696. 

  696.   <<__Native("ZendCompat")>>
    697. 

  697.   public function tailable(mixed $tail): mixed;
    698. 

  698. 

  699. /* A timeout can be set at any time and will affect subsequent queries on the
    700. 

  700.  * cursor, including fetching more results from the database.
    701. 

  701.  */
    702. 

  702.   <<__Native("ZendCompat")>>
    703. 

  703.   public function timeout(mixed $ms): mixed;
    704. 

  704. 

  705.   <<__Native("ZendCompat")>>
    706. 

  706.   public function valid(): mixed;
    707. 

  707. }
    708. 

  708. 

  709. /* A unique identifier created for database objects. If an object is inserted
    710. 

  710.  * into the database without an _id field, an _id field will be added to it
    711. 

  711.  * with a MongoId instance as its value. If the data has a naturally occuring
    712. 

  712.  * unique field (say, a username or timestamp) it is fine to use this as the
    713. 

  713.  * _id field instead, and it will not be replaced with a MongoId.  Instances
    714. 

  714.  * of the MongoId class fulfill the role that autoincrementing does in a
    715. 

  715.  * relational database: to provide a unique key if the data does not natually
    716. 

  716.  * have one. Autoincrementing does not work well with a sharded database, as
    717. 

  717.  * it is impossible to find what the next number should be quickly. This class
    718. 

  718.  * fulfills the constraints of quickly generating a value that is unique
    719. 

  719.  * across shards.  Each MongoId is 12 bytes (making its string form 24
    720. 

  720.  * hexidecimal characters). The first four bytes are a timestamp, the next
    721. 

  721.  * three are a hash of the client machine's hostname, the next two are the two
    722. 

  722.  * least significant bytes of the process id running the script, and the last
    723. 

  723.  * three bytes are an incrementing value.  MongoIds are
    724. 

  724.  * serializable/unserializable. Their serialized form is similar to their
    725. 

  725.  * string form: C:7:"MongoId":24:{4af9f23d8ead0e1d32000000}
    726. 

  726.  */
    727. 

  727. <<__NativeData("ZendCompat")>>
    728. 

  728. class MongoId {
    729. 

  729.   <<__Native("ZendCompat")>>
    730. 

  730.   public function __construct(mixed $id);
    731. 

  731. 

  732.   /* This returns the hostname MongoId is using to generate unique ids. This
    733. 

  733.    * should be the same value gethostname() returns.  It is identical to the
    734. 

  734.    * function:
    735. 

  735.    */
    736. 

  736.   <<__Native("ZendCompat")>>
    737. 

  737.   public static function getHostname(): mixed;
    738. 

  738. 

  739.   <<__Native("ZendCompat")>>
    740. 

  740.   public function getInc(): mixed;
    741. 

  741. 

  742.   /* Extracts the pid from the Mongo ID
    743. 

  743.    */
    744. 

  744.   <<__Native("ZendCompat")>>
    745. 

  745.   public function getPID(): mixed;
    746. 

  746. 

  747.   /* This returns the same thing as running time() when the id is created.
    748. 

  748.    */
    749. 

  749.   <<__Native("ZendCompat")>>
    750. 

  750.   public function getTimestamp(): mixed;
    751. 

  751. 

  752.   /* This function is only used by PHP internally, it shouldn't need to ever be
    753. 

  753.    * called by the user.  It is identical to the function:
    754. 

  754.    */
    755. 

  755.   <<__Native("ZendCompat")>>
    756. 

  756.   public static function __set_state(mixed $props): mixed;
    757. 

  757. 

  758.   <<__Native("ZendCompat")>>
    759. 

  759.   public function __toString(): mixed;
    760. 

  760. }
    761. 

  761. 

  762. /* Represents JavaScript code for the database.  MongoCode objects are
    763. 

  763.  * composed of two parts: a string of code and an optional scope. The string
    764. 

  764.  * of code must be valid JavaScript. The scope is a associative array of
    765. 

  765.  * variable name/value pairs.
    766. 

  766.  */
    767. 

  767. <<__NativeData("ZendCompat")>>
    768. 

  768. class MongoCode {
    769. 

  769.   public string $code = '';
    770. 

  770.   public mixed $scope;
    771. 

  771. 

  772.   <<__Native("ZendCompat")>>
    773. 

  773.   public function __construct(mixed $code,
    774. 

  774.                               mixed $scope);
    775. 

  775. 

  776.   <<__Native("ZendCompat")>>
    777. 

  777.   public function __toString(): mixed;
    778. 

  778. }
    779. 

  779. 

  780. /* Represent date objects for the database. This class should be used to save
    781. 

  781.  * dates to the database and to query for dates. For example: Example #1
    782. 

  782.  * Storing dates with MongoDate    MongoDB stores dates as milliseconds past
    783. 

  783.  * the epoch. This means that dates do not contain timezone information.
    784. 

  784.  * Timezones must be stored in a separate field if needed. Second, this means
    785. 

  785.  * that any precision beyond milliseconds will be lost when the document is
    786. 

  786.  * sent to/from the database.
    787. 

  787.  */
    788. 

  788. <<__NativeData("ZendCompat")>>
    789. 

  789. class MongoDate {
    790. 

  790.   public int $sec = 0;
    791. 

  791.   public int $usec = 0;
    792. 

  792. 

  793.   /* Creates a new date. If no parameters are given, the current time is used.
    794. 

  794.    */
    795. 

  795.   <<__Native("ZendCompat")>>
    796. 

  796.   public function __construct(mixed $sec,
    797. 

  797.                               mixed $usec);
    798. 

  798. 

  799.   /* Returns a string representation of this date, similar to the representation
    800. 

  800.    * returned by microtime().
    801. 

  801.    */
    802. 

  802.   <<__Native("ZendCompat")>>
    803. 

  803.   public function __toString(): mixed;
    804. 

  804. }
    805. 

  805. 

  806. /* This class can be used to create regular expressions. Typically, these
    807. 

  807.  * expressions will be used to query the database and find matching strings.
    808. 

  808.  * More unusually, they can be saved to the database and retrieved.  Regular
    809. 

  809.  * expressions consist of four parts. First a / as starting delimiter, then
    810. 

  810.  * then pattern, another / and finally a string containing flags.  Example #1
    811. 

  811.  * Regular expression pattern /pattern/flags  MongoDB recognizes six regular
    812. 

  812.  * expression flags:  i: Case insensitive  m: Multiline  x: Can contain
    813. 

  813.  * comments  l: locale  s: dotall, "." matches everything, including newlines
    814. 

  814.  * u: match unicode
    815. 

  815.  */
    816. 

  816. <<__NativeData("ZendCompat")>>
    817. 

  817. class MongoRegex {
    818. 

  818.   public string $regex = '';
    819. 

  819.   public string $flags = '';
    820. 

  820. 

  821.   /* Creates a new regular expression.
    822. 

  822.    */
    823. 

  823.   <<__Native("ZendCompat")>>
    824. 

  824.   public function __construct(mixed $regex);
    825. 

  825. 

  826.   /* Returns a string representation of this regular expression.
    827. 

  827.    */
    828. 

  828.   <<__Native("ZendCompat")>>
    829. 

  829.   public function __toString(): mixed;
    830. 

  830. }
    831. 

  831. 

  832. /* An object that can be used to store or retrieve binary data from the
    833. 

  833.  * database.  The maximum size of a single object that can be inserted into
    834. 

  834.  * the database is 16MB. For data that is larger than this (movies, music,
    835. 

  835.  * Henry Kissinger's autobiography), use MongoGridFS. For data that is smaller
    836. 

  836.  * than 16MB, you may find it easier to embed it within the document using
    837. 

  837.  * MongoBinData.  For example, to embed an image in a document, one could
    838. 

  838.  * write:    This class contains a type field, which currently gives no
    839. 

  839.  * additional functionality in the driver or the database. There are five
    840. 

  840.  * predefined types (which are the class constants listed below), and the user
    841. 

  841.  * can create their own (at the risk of the BSON spec catching up with them).
    842. 

  842.  * By default, the PHP driver always uses type 2: a byte array.
    843. 

  843.  */
    844. 

  844. <<__NativeData("ZendCompat")>>
    845. 

  845. class MongoBinData {
    846. 

  846.   public string $bin = '';
    847. 

  847.   public int $type = 0;
    848. 

  848. 

  849.   /* Creates a new binary data object.  There are five types of binary data
    850. 

  850.    * currently recognized by the BSON spec: function (0x01), byte array (0x02),
    851. 

  851.    * UUID (0x03), MD5 (0x05), and user defined (0x80). The default type is byte
    852. 

  852.    * array (0x02). There is no particular difference in how the driver or server
    853. 

  853.    * interpret different types, so by and large they are irrelevant for now. Any
    854. 

  854.    * number (between 0 and 255) could be used for type, if the user is willing
    855. 

  855.    * to assume the risk that the database might eventually do something with
    856. 

  856.    * binary data based on type.
    857. 

  857.    */
    858. 

  858.   <<__Native("ZendCompat")>>
    859. 

  859.   public function __construct(mixed $data,
    860. 

  860.                               mixed $type);
    861. 

  861. 

  862.   <<__Native("ZendCompat")>>
    863. 

  863.   public function __toString(): mixed;
    864. 

  864. }
    865. 

  865. 

  866. /* The class can be used to save 32-bit integers to the database on a 64-bit
    867. 

  867.  * system.
    868. 

  868.  */
    869. 

  869. <<__NativeData("ZendCompat")>>
    870. 

  870. class MongoInt32 {
    871. 

  871.   public string $value = '';
    872. 

  872. 

  873.   /* Creates a new 32-bit number with the given value.
    874. 

  874.    */
    875. 

  875.   <<__Native("ZendCompat")>>
    876. 

  876.   public function __construct(mixed $value);
    877. 

  877. 

  878.   <<__Native("ZendCompat")>>
    879. 

  879.   public function __toString(): mixed;
    880. 

  880. }
    881. 

  881. 

  882. /* The class can be used to save 64-bit integers to the database on a 32-bit
    883. 

  883.  * system.
    884. 

  884.  */
    885. 

  885. <<__NativeData("ZendCompat")>>
    886. 

  886. class MongoInt64 {
    887. 

  887.   public string $value = '';
    888. 

  888. 

  889.   /* Creates a new 64-bit number with the given value.
    890. 

  890.    */
    891. 

  891.   <<__Native("ZendCompat")>>
    892. 

  892.   public function __construct(mixed $value);
    893. 

  893. 

  894.   <<__Native("ZendCompat")>>
    895. 

  895.   public function __toString(): mixed;
    896. 

  896. }
    897. 

  897. 

  898. /* This class can be used to create lightweight links between objects in
    899. 

  899.  * different collections.  Motivation: Suppose we need to refer to a document
    900. 

  900.  * in another collection. The easiest way is to create a field in the current
    901. 

  901.  * document. For example, if we had a "people" collection and an "addresses"
    902. 

  902.  * collection, we might want to create a link between each person document and
    903. 

  903.  * an address document: Example #1 Linking documents    Then, later on, we can
    904. 

  904.  * find the person's address by querying the "addresses" collection with the
    905. 

  905.  * MongoId we saved in the "people" collection.  Suppose now that we have a
    906. 

  906.  * more general case, where we don't know which collection (or even which
    907. 

  907.  * database) contains the referenced document. MongoDBRef is a good choice for
    908. 

  908.  * this case, as it is a common format that all of the drivers and the
    909. 

  909.  * database understand.  If each person had a list of things they liked which
    910. 

  910.  * could come from multiple collections, such as "hobbies", "sports", "books",
    911. 

  911.  * etc., we could use MongoDBRefs to keep track of what "like" went with what
    912. 

  912.  * collection: Example #2 Creating MongoDBRef links    Database references can
    913. 

  913.  * be thought of as hyperlinks: they give the unique address of another
    914. 

  914.  * document, but they do not load it or automatically follow the
    915. 

  915.  * link/reference.  A database reference is just a normal associative array,
    916. 

  916.  * not an instance of MongoDBRef, so this class is a little different than the
    917. 

  917.  * other data type classes. This class contains exclusively static methods for
    918. 

  918.  * manipulating database references.
    919. 

  919.  */
    920. 

  920. <<__NativeData("ZendCompat")>>
    921. 

  921. class MongoDBRef {
    922. 

  922.   protected static string $refKey = '$ref';
    923. 

  923.   protected static string $idKey = '$id';
    924. 

  924. 

  925.   /* If no database is given, the current database is used.
    926. 

  926.    */
    927. 

  927.   <<__Native("ZendCompat")>>
    928. 

  928.   public static function create(mixed $collection,
    929. 

  929.                          mixed $id,
    930. 

  930.                          mixed $database): mixed;
    931. 

  931. 

  932.   <<__Native("ZendCompat")>>
    933. 

  933.   public static function get(mixed $db,
    934. 

  934.                       mixed $ref): mixed;
    935. 

  935. 

  936.   /* This method does not actually follow the reference, so it does not
    937. 

  937.    * determine if it is broken or not. It merely checks that ref is in valid
    938. 

  938.    * database reference format (in that it is an object or array with $ref and
    939. 

  939.    * $id fields).
    940. 

  940.    */
    941. 

  941.   <<__Native("ZendCompat")>>
    942. 

  942.   public static function isRef(mixed $ref): mixed;
    943. 

  943. }
    944. 

  944. 

  945. /* MongoMinKey is a special type used by the database that evaluates to less
    946. 

  946.  * than any other type. Thus, if a query is sorted by a given field in
    947. 

  947.  * ascending order, any document with a MongoMinKey as its value will be
    948. 

  948.  * returned first.  MongoMinKey has no associated fields, methods, or
    949. 

  949.  * constants. It is merely the "smallest" thing that can be inserted into the
    950. 

  950.  * database.
    951. 

  951.  */
    952. 

  952. <<__NativeData("ZendCompat")>>
    953. 

  953. class MongoMinKey {
    954. 

  954. }
    955. 

  955. 

  956. /* MongoMaxKey is a special type used by the database that evaluates to
    957. 

  957.  * greater than any other type. Thus, if a query is sorted by a given field in
    958. 

  958.  * ascending order, any document with a MongoMaxKey as its value will be
    959. 

  959.  * returned last.  MongoMaxKey has no associated fields, methods, or
    960. 

  960.  * constants. It is merely the "largest" thing that can be inserted into the
    961. 

  961.  * database.
    962. 

  962.  */
    963. 

  963. <<__NativeData("ZendCompat")>>
    964. 

  964. class MongoMaxKey {
    965. 

  965. }
    966. 

  966. 

  967. /* MongoTimestamp is used by sharding. If you're not looking to write sharding
    968. 

  968.  * tools, what you probably want is MongoDate.  MongoTimestamp is 4 bytes of
    969. 

  969.  * timestamp (seconds since the epoch) and 4 bytes of increment.  This class
    970. 

  970.  * is not for measuring time, creating a timestamp on a document or
    971. 

  971.  * automatically adding or updating a timestamp on a document. Unless you are
    972. 

  972.  * writing something that interacts with the sharding internals, stop, go
    973. 

  973.  * directly to MongoDate, do not pass go, do not collect 200 dollars. This is
    974. 

  974.  * not the class you are looking for.  If you are writing sharding tools, read
    975. 

  975.  * on.
    976. 

  976.  */
    977. 

  977. <<__NativeData("ZendCompat")>>
    978. 

  978. class MongoTimestamp {
    979. 

  979.   public int $sec = 0;
    980. 

  980.   public int $inc = 0;
    981. 

  981. 

  982.   /* Creates a new timestamp. If no parameters are given, the current time is
    983. 

  983.    * used and the increment is automatically provided. The increment is set to 0
    984. 

  984.    * when the module is loaded and is incremented every time this constructor is
    985. 

  985.    * called (without the $inc parameter passed in).
    986. 

  986.    */
    987. 

  987.   <<__Native("ZendCompat")>>
    988. 

  988.   public function __construct(mixed $sec,
    989. 

  989.                               mixed $inc);
    990. 

  990. 

  991.   /* Returns the "sec" field of this timestamp.
    992. 

  992.    */
    993. 

  993.   <<__Native("ZendCompat")>>
    994. 

  994.   public function __toString(): mixed;
    995. 

  995. }
    996. 

  996. 

  997. /* Utilities for storing and retrieving files from the database.  GridFS is a
    998. 

  998.  * storage specification all supported drivers implement. Basically, it
    999. 

  999.  * defines two collections: files, for file metadata, and chunks, for file
    1000. 

  1000.  * content. If the file is large, it will automatically be split into smaller
    1001. 

  1001.  * chunks and each chunk will be saved as a document in the chunks collection.
    1002. 

  1002.  *  Each document in the files collection contains the filename, upload date,
    1003. 

  1003.  * and md5 hash. It also contains a unique _id field, which can be used to
    1004. 

  1004.  * query the chunks collection for the file's content. Each document in the
    1005. 

  1005.  * chunks collection contains a chunk of binary data, a files_id field that
    1006. 

  1006.  * matches its file's _id, and the position of this chunk in the overall file.
    1007. 

  1007.  *  For example, the files document is something like:  and the chunks
    1008. 

  1008.  * documents look like:  Of course, the default chunk size is thousands of
    1009. 

  1009.  * bytes, but that makes an unwieldy example.
    1010. 

  1010.  */
    1011. 

  1011. <<__NativeData("ZendCompat")>>
    1012. 

  1012. class MongoGridFS extends MongoCollection {
    1013. 

  1013.   public mixed $chunks;
    1014. 

  1014.   protected mixed $filesName;
    1015. 

  1015.   protected mixed $chunksName;
    1016. 

  1016. 

  1017.   /* Files as stored across two collections, the first containing file meta
    1018. 

  1018.    * information, the second containing chunks of the actual file. By default,
    1019. 

  1019.    * fs.files and fs.chunks are the collection names used.  Use one argument to
    1020. 

  1020.    * specify a prefix other than "fs": $fs = new MongoGridFS($db, "myfiles");
    1021. 

  1021.    * uses myfiles.files and myfiles.chunks collections.
    1022. 

  1022.    */
    1023. 

  1023.   <<__Native("ZendCompat")>>
    1024. 

  1024.   public function __construct();
    1025. 

  1025. 

  1026.   <<__Native("ZendCompat")>>
    1027. 

  1027.   public function delete(mixed $id): mixed;
    1028. 

  1028. 

  1029.   <<__Native("ZendCompat")>>
    1030. 

  1030.   public function drop(): mixed;
    1031. 

  1031. 

  1032.   <<__Native("ZendCompat")>>
    1033. 

  1033.   public function find(mixed $query,
    1034. 

  1034.                        mixed $fields): mixed;
    1035. 

  1035. 

  1036.   <<__Native("ZendCompat")>>
    1037. 

  1037.   public function findOne(mixed $query): mixed;
    1038. 

  1038. 

  1039.   <<__Native("ZendCompat")>>
    1040. 

  1040.   public function get(mixed $id): mixed;
    1041. 

  1041. 

  1042.   <<__Native("ZendCompat")>>
    1043. 

  1043.   public function put(mixed $filename,
    1044. 

  1044.                       mixed $metadata): mixed;
    1045. 

  1045. 

  1046.   <<__Native("ZendCompat")>>
    1047. 

  1047.   public function remove(mixed $query,
    1048. 

  1048.                          mixed $options): mixed;
    1049. 

  1049. 

  1050.   <<__Native("ZendCompat")>>
    1051. 

  1051.   public function storeBytes(mixed $bytes,
    1052. 

  1052.                              mixed $metadata,
    1053. 

  1053.                              mixed $options): mixed;
    1054. 

  1054. 

  1055.   <<__Native("ZendCompat")>>
    1056. 

  1056.   public function storeFile(mixed $filename,
    1057. 

  1057.                             mixed $metadata,
    1058. 

  1058.                             mixed $options): mixed;
    1059. 

  1059. 

  1060.   <<__Native("ZendCompat")>>
    1061. 

  1061.   public function storeUpload(mixed $name,
    1062. 

  1062.                               mixed $metadata): mixed;
    1063. 

  1063. }
    1064. 

  1064. 

  1065. /* A database file object.
    1066. 

  1066.  */
    1067. 

  1067. <<__NativeData("ZendCompat")>>
    1068. 

  1068. class MongoGridFSFile {
    1069. 

  1069.   public mixed $file;
    1070. 

  1070.   protected mixed $gridfs;
    1071. 

  1071. 

  1072.   <<__Native("ZendCompat")>>
    1073. 

  1073.   public function __construct(mixed $gridfs,
    1074. 

  1074.                               mixed $file);
    1075. 

  1075. 

  1076.   /* Warning: this will load the file into memory. If the file is bigger than
    1077. 

  1077.    * your memory, this will cause problems!
    1078. 

  1078.    */
    1079. 

  1079.   <<__Native("ZendCompat")>>
    1080. 

  1080.   public function getBytes(): mixed;
    1081. 

  1081. 

  1082.   <<__Native("ZendCompat")>>
    1083. 

  1083.   public function getFilename(): mixed;
    1084. 

  1084. 

  1085.   /* This method returns a stream resource that can be used with all file
    1086. 

  1086.    * functions in PHP that deal with reading files. The contents of the file are
    1087. 

  1087.    * pulled out of MongoDB on the fly, so that the whole file does not have to
    1088. 

  1088.    * be loaded into memory first.  At most two GridFSFile chunks will be loaded
    1089. 

  1089.    * in memory.
    1090. 

  1090.    */
    1091. 

  1091.   <<__Native("ZendCompat")>>
    1092. 

  1092.   public function getResource(): mixed;
    1093. 

  1093. 

  1094.   <<__Native("ZendCompat")>>
    1095. 

  1095.   public function getSize(): mixed;
    1096. 

  1096. 

  1097.   <<__Native("ZendCompat")>>
    1098. 

  1098.   public function write(mixed $filename): mixed;
    1099. 

  1099. }
    1100. 

  1100. 

  1101. /* Cursor for database file results.
    1102. 

  1102.  */
    1103. 

  1103. <<__NativeData("ZendCompat")>>
    1104. 

  1104. class MongoGridFSCursor extends MongoCursor {
    1105. 

  1105.   protected mixed $gridfs;
    1106. 

  1106. 

  1107.   <<__Native("ZendCompat")>>
    1108. 

  1108.   public function __construct(mixed $gridfs,
    1109. 

  1109.                               mixed $connection,
    1110. 

  1110.                               mixed $ns,
    1111. 

  1111.                               mixed $query,
    1112. 

  1112.                               mixed $fields);
    1113. 

  1113. 

  1114.   <<__Native("ZendCompat")>>
    1115. 

  1115.   public function current(): mixed;
    1116. 

  1116. 

  1117.   <<__Native("ZendCompat")>>
    1118. 

  1118.   public function getNext(): mixed;
    1119. 

  1119. }
    1120. 

  1120. 

  1121. /* Logging can be used to get detailed information about what the driver is
    1122. 

  1122.  * doing. The logging mechanism as used by MongoLog emits all log messages as
    1123. 

  1123.  * a PHP notice. Depending on the server interface that you use, that means
    1124. 

  1124.  * that they will either be sent to strerr (with PHP-CLI), or otherwise to the
    1125. 

  1125.  * web server's error log. In order for log messages to be output by PHP their
    1126. 

  1126.  * level (E_NOTICE) does need to be configured to be shown. That means the
    1127. 

  1127.  * E_NOTICE bit needs to be part of PHP's error_reporting level and that
    1128. 

  1128.  * display_errors is set to 1.  Logging is turned off, by default. This class
    1129. 

  1129.  * allows you to turn on specific levels of logging for specific parts of the
    1130. 

  1130.  * driver. Some examples:
    1131. 

  1131.  */
    1132. 

  1132. <<__NativeData("ZendCompat")>>
    1133. 

  1133. class MongoLog {
    1134. 

  1134.   private static int $level = 0;
    1135. 

  1135.   private static int $module = 0;
    1136. 

  1136.   private static mixed $callback = 0;
    1137. 

  1137. 

  1138.   /* Retrieves the callback function name.
    1139. 

  1139.    */
    1140. 

  1140.   <<__Native("ZendCompat")>>
    1141. 

  1141.   public static function getCallback(): mixed;
    1142. 

  1142. 

  1143.   /* This can be used to see the log level. Use the constants described in the
    1144. 

  1144.    * MongoLog section with bitwise operators to check the level.
    1145. 

  1145.    */
    1146. 

  1146.   <<__Native("ZendCompat")>>
    1147. 

  1147.   public static function getLevel(): mixed;
    1148. 

  1148. 

  1149.   /* This function can be used to see which parts of the driver's functionality
    1150. 

  1150.    * are being logged. Use the constants described in the MongoLog section with
    1151. 

  1151.    * bitwise operators to check if specific modules are being logged.
    1152. 

  1152.    */
    1153. 

  1153.   <<__Native("ZendCompat")>>
    1154. 

  1154.   public static function getModule(): mixed;
    1155. 

  1155. 

  1156.   /* This function will set a callback function to be called for MongoLog events
    1157. 

  1157.    * instead of triggering warnings.
    1158. 

  1158.    */
    1159. 

  1159.   <<__Native("ZendCompat")>>
    1160. 

  1160.   public static function setCallback(mixed $log_function,
    1161. 

  1161.                               mixed $module,
    1162. 

  1162.                               mixed $level): mixed;
    1163. 

  1163. 

  1164.   /* This function can be used to set how verbose logging should be and the
    1165. 

  1165.    * types of activities that should be logged. Use the constants described in
    1166. 

  1166.    * the MongoLog section with bitwise operators to specify levels.    Note that
    1167. 

  1167.    * you must also call MongoLog::setModule() to choose what part of the driver
    1168. 

  1168.    * to log.
    1169. 

  1169.    */
    1170. 

  1170.   <<__Native("ZendCompat")>>
    1171. 

  1171.   public static function setLevel(mixed $level): mixed;
    1172. 

  1172. 

  1173.   /* This function can be used to set which parts of the driver's functionality
    1174. 

  1174.    * should be logged. Use the constants described in the MongoLog section with
    1175. 

  1175.    * bitwise operators to specify modules.    Note that you must also call
    1176. 

  1176.    * MongoLog::setLevel() to turn on logging.
    1177. 

  1177.    */
    1178. 

  1178.   <<__Native("ZendCompat")>>
    1179. 

  1179.   public static function setModule(mixed $module): mixed;
    1180. 

  1180. }
    1181. 

  1181. 

  1182. /* Warning  The current (1.3.0+) releases of the driver no longer implements
    1183. 

  1183.  * pooling. This class and its methods are therefore deprecated and should not
    1184. 

  1184.  * be used.
    1185. 

  1185.  */
    1186. 

  1186. <<__NativeData("ZendCompat")>>
    1187. 

  1187. class MongoPool {
    1188. 

  1188. 

  1189.   <<__Native("ZendCompat")>>
    1190. 

  1190.   public static function getSize(): mixed;
    1191. 

  1191. 

  1192.   /* Returns an array of information about all connection pools.
    1193. 

  1193.    */
    1194. 

  1194.   <<__Native("ZendCompat")>>
    1195. 

  1195.   public static function info(): mixed;
    1196. 

  1196. 

  1197.   /* Sets the max number of connections new pools will be able to create.
    1198. 

  1198.    */
    1199. 

  1199.   <<__Native("ZendCompat")>>
    1200. 

  1200.   public static function setSize(mixed $size): mixed;
    1201. 

  1201. }
    1202. 

  1202. 

  1203. /* A connection between PHP and MongoDB.  This class extends MongoClient and
    1204. 

  1204.  * provides access to several deprecated methods.  For backwards
    1205. 

  1205.  * compatibility, it also defaults the "w" option of its constructor argument
    1206. 

  1206.  * to 0, which does not require write operations to be acknowledged by the
    1207. 

  1207.  * server. See MongoClient::__construct() for more information. Warning This
    1208. 

  1208.  * class has been DEPRECATED as of version 1.3.0. Relying on this feature is
    1209. 

  1209.  * highly discouraged. Please use MongoClient instead.
    1210. 

  1210.  */
    1211. 

  1211. <<__NativeData("ZendCompat")>>
    1212. 

  1212. class Mongo extends MongoClient {
    1213. 

  1213. 

  1214.   <<__Native("ZendCompat")>>
    1215. 

  1215.   public function connectUtil(): mixed;
    1216. 

  1216. 

  1217.   /* This method overwrites the MongoClient constructor and turns off
    1218. 

  1218.    * acknowledged writes.  Please see MongoClient::__construct() for description
    1219. 

  1219.    * of the parameters.
    1220. 

  1220.    */
    1221. 

  1221.   <<__Native("ZendCompat")>>
    1222. 

  1222.   public function __construct(mixed $server = null, mixed $options = null);
    1223. 

  1223. 

  1224.   <<__Native("ZendCompat")>>
    1225. 

  1225.   public static function getPoolSize(): mixed;
    1226. 

  1226. 

  1227.   /* This finds the address of the secondary currently being used for reads. It
    1228. 

  1228.    * is a read-only method: it does not change anything about the internal state
    1229. 

  1229.    * of the object.  When you create a connection to the database, the driver
    1230. 

  1230.    * will not immediately decide on a secondary to use. Thus, after you connect,
    1231. 

  1231.    * this function will return NULL even if there are secondaries available.
    1232. 

  1232.    * When you first do a query with slaveOkay set, at that point the driver will
    1233. 

  1233.    * choose a secondary for this connection. At that point, this function will
    1234. 

  1234.    * return the chosen secondary.  See the query section of this manual for
    1235. 

  1235.    * information on distributing reads to secondaries.
    1236. 

  1236.    */
    1237. 

  1237.   <<__Native("ZendCompat")>>
    1238. 

  1238.   public function getSlave(): mixed;
    1239. 

  1239. 

  1240.   /* See the query section of this manual for information on distributing reads
    1241. 

  1241.    * to secondaries.
    1242. 

  1242.    */
    1243. 

  1243.   <<__Native("ZendCompat")>>
    1244. 

  1244.   public function getSlaveOkay(): mixed;
    1245. 

  1245. 

  1246.   <<__Native("ZendCompat")>>
    1247. 

  1247.   public static function poolDebug(): mixed;
    1248. 

  1248. 

  1249.   <<__Native("ZendCompat")>>
    1250. 

  1250.   public static function setPoolSize(mixed $size): mixed;
    1251. 

  1251. 

  1252.   /* See the query section of this manual for information on distributing reads
    1253. 

  1253.    * to secondaries.
    1254. 

  1254.    */
    1255. 

  1255.   <<__Native("ZendCompat")>>
    1256. 

  1256.   public function setSlaveOkay(mixed $ok): mixed;
    1257. 

  1257. 

  1258.   /* This choses a random secondary for a connection to read from. It is called
    1259. 

  1259.    * automatically by the driver and should not need to be used. It calls
    1260. 

  1260.    * MongoClient::getHosts() (to refresh the status of hosts) and
    1261. 

  1261.    * Mongo::getSlave() (to get the return value).  See the query section of this
    1262. 

  1262.    * manual for information on distributing reads to secondaries.
    1263. 

  1263.    */
    1264. 

  1264.   <<__Native("ZendCompat")>>
    1265. 

  1265.   public function switchSlave(): mixed;
    1266. 

  1266. }
    1267. 

  1267. 

  1268. /* Default Mongo exception.  This covers a bunch of different error conditions
    1269. 

  1269.  * that may eventually be moved to more specific exceptions, but will always
    1270. 

  1270.  * extend MongoException.  The MongoSomething object has not been correctly
    1271. 

  1271.  * initialized by its constructor  Code: 0  Probably your Mongo object is not
    1272. 

  1272.  * connected to a database server.  zero-length keys are not allowed, did you
    1273. 

  1273.  * use $ with double quotes?  Code: 1  You tried to save "" as a key. You
    1274. 

  1274.  * generally should not do this. "" can mess up subobject access and is used
    1275. 

  1275.  * by MongoDB internally. However, if you really want, you can set
    1276. 

  1276.  * mongo.allow_empty_keys to true in your php.ini file to override this sanity
    1277. 

  1277.  * check. If you override this, it is highly recommended that you set error
    1278. 

  1278.  * checking to strict to avoid string interpolation errors.  '.' not allowed
    1279. 

  1279.  * in key: <key>  Code: 2  You attempted to write a key with '.' in it, which
    1280. 

  1280.  * is prohibited.  insert too large: <size>, max: <max>  Code: 3  You're
    1281. 

  1281.  * attempting to send too much data to the database at once: the database will
    1282. 

  1282.  * only accept inserts up to a certain size (currently 16 MB).  no elements in
    1283. 

  1283.  * doc  Code: 4  You're attempting to save a document with no fields.  size of
    1284. 

  1284.  * BSON doc is <size> bytes, max <max>MB  Code: 5  You're attempting to save a
    1285. 

  1285.  * document that is larger than MongoDB can save.  no documents given  Code: 6
    1286. 

  1286.  *  You're attempting to batch insert an empty array of documents.
    1287. 

  1287.  * MongoCollection::group takes an array, object, or MongoCode key  Code: 7
    1288. 

  1288.  * Wrong type parameter send to MongoCollection::group().  field names must be
    1289. 

  1289.  * strings  Code: 8  You should format field selectors as array("field1" => 1,
    1290. 

  1290.  * "field2" => 1, ..., "fieldN" => 1).  invalid regex  Code: 9  The regex
    1291. 

  1291.  * passed to MongoRegex is not of the correct form.  MongoDBRef::get: $ref
    1292. 

  1292.  * field must be a string  Code: 10  MongoDBRef::get: $db field must be a
    1293. 

  1293.  * string  Code: 11  non-utf8 string: <str>  Code: 12  This error occurs if
    1294. 

  1294.  * you attempt to send a non-utf8 string to the database. All strings going
    1295. 

  1295.  * into the database should be UTF8. See php.ini options for the transition
    1296. 

  1296.  * option of quieting this exception.  mutex error: <err>  Code: 13  The
    1297. 

  1297.  * driver uses mutexes for synchronizing requests and responses in
    1298. 

  1298.  * multithreaded environments. This is a fairly serious error and may not have
    1299. 

  1299.  * a stack trace. It's unusual and should be reported to maintainers with any
    1300. 

  1300.  * system information and steps to reproduce that you can provide.  index name
    1301. 

  1301.  * too long: <len>, max <max> characters  Code: 14  Indexes with names longer
    1302. 

  1302.  * than 128 characters cannot be created. If you get this error, you should
    1303. 

  1303.  * use MongoCollection::ensureIndex()'s "name" option to create a shorter name
    1304. 

  1304.  * for your index.
    1305. 

  1305.  */
    1306. 

  1306. <<__NativeData("ZendCompat")>>
    1307. 

  1307. class MongoException extends Exception {
    1308. 

  1308. }
    1309. 

  1309. 

  1310. /* The MongoResultException is thrown by several command helpers (such as
    1311. 

  1311.  * MongoCollection::findAndModify()) in the event of failure. The original
    1312. 

  1312.  * result document is available through MongoResultException::getDocument().
    1313. 

  1313.  */
    1314. 

  1314. <<__NativeData("ZendCompat")>>
    1315. 

  1315. class MongoResultException extends MongoException {
    1316. 

  1316.   public mixed $document;
    1317. 

  1317. 

  1318.   /* Retrieves the full error result document.
    1319. 

  1319.    */
    1320. 

  1320.   <<__Native("ZendCompat")>>
    1321. 

  1321.   public function getDocument(): mixed;
    1322. 

  1322. }
    1323. 

  1323. 

  1324. /* Caused by accessing a cursor incorrectly or a error receiving a reply. Note
    1325. 

  1325.  * that this can be thrown by any database request that receives a reply, not
    1326. 

  1326.  * just queries. Writes, commands, and any other operation that sends
    1327. 

  1327.  * information to the database and waits for a response can throw a
    1328. 

  1328.  * MongoCursorException. The only exception is new MongoClient() (creating a
    1329. 

  1329.  * new connection), which will only throw MongoConnectionExceptions.  This
    1330. 

  1330.  * returns a specific error message to help diagnose the problem and a numeric
    1331. 

  1331.  * error code associated with the cause of the exception.  For example,
    1332. 

  1332.  * suppose you tried to insert two documents with the same _id:  This would
    1333. 

  1333.  * produce output like:  Note that the MongoDB error code (11000) is used for
    1334. 

  1334.  * the PHP error code. The PHP driver uses the "native" error code wherever
    1335. 

  1335.  * possible.  The following is a list of common errors, codes, and causes.
    1336. 

  1336.  * Exact errors are in italics, errors where the message can vary are
    1337. 

  1337.  * described in obliques.  cannot modify cursor after beginning iteration
    1338. 

  1338.  * Code: 0  You are calling a method that sets up the query after executing
    1339. 

  1339.  * the query. Reset the cursor and try again.  An example:    Get next batch
    1340. 

  1340.  * send errors  Code: 1  Could not send the query to the database. Make sure
    1341. 

  1341.  * the database is still up and the network is okay.  cursor not found  Code:
    1342. 

  1342.  * 2  The driver was trying to fetch more results from the database, but the
    1343. 

  1343.  * database did not have a record of the query. This usually means that the
    1344. 

  1344.  * cursor timed out on the server side: after a few minutes of inactivity, the
    1345. 

  1345.  * database will kill a cursor (see MongoCursor::immortal() for information on
    1346. 

  1346.  * preventing this).  An example:    cursor->buf.pos is null  Code: 3  This
    1347. 

  1347.  * may indicate you are out of RAM or some other extraordinary circumstance.
    1348. 

  1348.  * couldn't get response header  Code: 4  A common error if the database or
    1349. 

  1349.  * network goes down. This means that the driver couldn't get a response from
    1350. 

  1350.  * the connection.  no db response  Code: 5  This may not even be an error,
    1351. 

  1351.  * for example, the database command "shutdown" returns no response. However,
    1352. 

  1352.  * if you were expecting a response, this means the database didn't give one.
    1353. 

  1353.  * bad response length: %d, did the db assert?  Code: 6  This means that the
    1354. 

  1354.  * database said that its response was less than 0. This error probably
    1355. 

  1355.  * indicates a network error or database corruption.  incomplete header  Code:
    1356. 

  1356.  * 7  Highly unusual. Occurs if the database response started out correctly,
    1357. 

  1357.  * but broke off in the middle. Probably indicates a network problem.
    1358. 

  1358.  * incomplete response  Code: 8  Highly unusual. Occurs if the database
    1359. 

  1359.  * response started out correctly, but broke off in the middle. Probably
    1360. 

  1360.  * indicates a network problem.  couldn't find a response  Code: 9  If the
    1361. 

  1361.  * response was cached and now cannot be located.  error getting socket  Code:
    1362. 

  1362.  * 10  The socket was closed or encountered an error. The driver should
    1363. 

  1363.  * automatically reconnect (if possible) on the next operation.  couldn't find
    1364. 

  1364.  * reply, please try again  Code: 11  The driver saves any database responses
    1365. 

  1365.  * it cannot immediately match with a request. This exception occurs if the
    1366. 

  1366.  * driver has already passed your request's response and cannot find your
    1367. 

  1367.  * response in its cache.  error getting database response: errstr  WSA error
    1368. 

  1368.  * getting database response: errstr  "errstr" is an io error reported
    1369. 

  1369.  * directly from the C socket subsystem. On Windows, the error message is
    1370. 

  1370.  * prefixed with "WSA".  Timeout error  Code: 13  If there was an error while
    1371. 

  1371.  * waiting for a query to complete.  couldn't send query: <various>  Code: 14
    1372. 

  1372.  * C socket error on send.  max number of retries exhausted, couldn't send
    1373. 

  1373.  * query  Code: 19  The driver will automatically retry "plain" queries (not
    1374. 

  1374.  * commands) a couple of times if the first attempt failed for certain
    1375. 

  1375.  * reasons. This is to cause fewer exceptions during replica set failover
    1376. 

  1376.  * (although you will probably still have to deal with some) and gloss over
    1377. 

  1377.  * transient network issues.  This can also be caused by the driver not being
    1378. 

  1378.  * able to reconnect at all to the database (if, for example, the database is
    1379. 

  1379.  * unreachable).  Version 1.2.2+.
    1380. 

  1380.  */
    1381. 

  1381. <<__NativeData("ZendCompat")>>
    1382. 

  1382. class MongoCursorException extends MongoException {
    1383. 

  1383.   private mixed $host;
    1384. 

  1384.   private int $fd = 0;
    1385. 

  1385. 

  1386.   /* Returns the hostname of the server the query was sent too.
    1387. 

  1387.    */
    1388. 

  1388.   <<__Native("ZendCompat")>>
    1389. 

  1389.   public function getHost(): mixed;
    1390. 

  1390. }
    1391. 

  1391. 

  1392. /* Caused by a query timing out. You can set the length of time to wait before
    1393. 

  1393.  * this exception is thrown by calling MongoCursor::timeout() on the cursor or
    1394. 

  1394.  * setting MongoCursor::$timeout. The static variable is useful for queries
    1395. 

  1395.  * such as database commands and MongoCollection::findOne(), both of which
    1396. 

  1396.  * implicitly use cursors.
    1397. 

  1397.  */
    1398. 

  1398. <<__NativeData("ZendCompat")>>
    1399. 

  1399. class MongoCursorTimeoutException extends MongoCursorException {
    1400. 

  1400. }
    1401. 

  1401. 

  1402. /* Thrown when the driver fails to connect to the database.  There are a
    1403. 

  1403.  * number of possible error messages to help you diagnose the connection
    1404. 

  1404.  * problem. These are:  No candidate servers found  Thrown when the driver
    1405. 

  1405.  * cannot establish a connection to MongoDB (fulfilling the ReadPreferences,
    1406. 

  1406.  * if specified).  No server name given.  This error occurs if you pass in ""
    1407. 

  1407.  * as the server name, probably because of an typo with string interpolation,
    1408. 

  1408.  * e.g., "$servr" instead of "$server".  failed to get host [hostname] or port
    1409. 

  1409.  * [portnum] from [server].  This indicated that the server string was
    1410. 

  1410.  * malformed. "[hostname]" and "[portnum]" will be as much as the driver could
    1411. 

  1411.  * dicipher of it.  Operation in progress  Connecting to the database timed
    1412. 

  1412.  * out.  Transport endpoint is not connected  Generally means that the
    1413. 

  1413.  * connection string isn't correct, the driver couldn't even find the database
    1414. 

  1414.  * server.  couldn't determine master  No server in a replica set connection
    1415. 

  1415.  * was identified as the primary.  couldn't get host info for [server]  This
    1416. 

  1416.  * indicated that DNS could not resolve the server address you gave. This
    1417. 

  1417.  * could easily be caused by a typo, for example, "server" instead of
    1418. 

  1418.  * "$server".  Invalid Argument  This can be caused by attempting to connect
    1419. 

  1419.  * to a machine that is up but that the database isn't actually running on.
    1420. 

  1420.  * Make sure that you've started the database server before connecting.
    1421. 

  1421.  * Permission denied  This means that the socket could not be opened due to
    1422. 

  1422.  * permissions issues. On Red Hat variants, this can be caused by a default
    1423. 

  1423.  * setting that does not allow Apache to create network connections. You can
    1424. 

  1424.  * override this setting by running:  then restarting Apache.  If the error
    1425. 

  1425.  * message is not listed above, it is probably an error from the C socket, and
    1426. 

  1426.  * you can search the web for its usual cause.
    1427. 

  1427.  */
    1428. 

  1428. <<__NativeData("ZendCompat")>>
    1429. 

  1429. class MongoConnectionException extends MongoException {
    1430. 

  1430. }
    1431. 

  1431. 

  1432. /* Thrown when there are errors reading or writing files to or from the
    1433. 

  1433.  * database.
    1434. 

  1434.  */
    1435. 

  1435. <<__NativeData("ZendCompat")>>
    1436. 

  1436. class MongoGridFSException extends MongoException {
    1437. 

  1437. }
    1438. 

  1438. 

  1439. /* This function is very beta and entirely useless for 99% of users. It is
    1440. 

  1440.  * only useful if you're doing something weird, such as writing your own
    1441. 

  1441.  * driver on top of the PHP driver.
    1442. 

  1442.  */
    1443. 

  1443. <<__Native("ZendCompat")>>
    1444. 

  1444. function bson_decode(mixed $bson): mixed;
    1445. 

  1445. 

  1446. /* This function is very beta and entirely useless for 99% of users. It is
    1447. 

  1447.  * only useful if you're doing something weird, such as writing your own
    1448. 

  1448.  * driver on top of the PHP driver.
    1449. 

  1449.  */
    1450. 

  1450. <<__Native("ZendCompat")>>
    1451. 

  1451. function bson_encode(mixed $anything): mixed;
    1452. 

  1452.