Trabalhe com Dados BSON

Dados de amostra

Os exemplos de código neste guia referenciam o seguinte documento BSON de exemplo :

{
    "address" : {
        "street" : "Pizza St",
        "zipcode" : "10003"
    },
    "coord" : [-73.982419, 41.579505]
    "cuisine" : "Pizza",
    "name" : "Planet Pizza"
}

Tipo Maps

Você pode definir a opção typeMap, que configura a serialização e a desserialização entre os valores PHP e BSON, nos seguintes níveis:

• MongoDB\Client, que define o padrão para todas as operações, a menos que sejam substituídas

• MongoDB\Database

• MongoDB\Collection

Esta lista também indica a ordem crescente de precedência das configurações de opção. Por exemplo, se você definir um typeMap para uma collection, ela substituirá o map de tipos definido no banco de dados.

A biblioteca PHP usa o seguinte mapa de tipos por padrão:

[
    'array' => 'MongoDB\Model\BSONArray',
    'document' => 'MongoDB\Model\BSONDocument',
    'root' => 'MongoDB\Model\BSONDocument',
]

Este mapa de tipos executa as seguintes conversões em ambas as direções:

• Arrays para MongoDB\Model\BSONArray objetos

• Documentos BSON incorporados e de nível superior em objetos MongoDB\Model\BSONDocument

Um mapa de tipos pode especificar qualquer classe que implemente a interface do MongoDB\BSON\Unserializable. Ele também pode especificar conversões dos tipos array, stdClass e object.

$options = [
    'typeMap' => [
        'array' => 'MongoDB\Model\BSONDocument',
        'root' => 'MongoDB\Model\BSONDocument',
        'document' => 'MongoDB\Model\BSONDocument',
    ],
];
$db->createCollection('restaurants', $options);

Classes persistentes

Você pode criar classes que implementam a interface MongoDB\BSON\Persistable. Essa interface instrui a biblioteca PHP a executar automaticamente a serialização e a desserialização de acordo com a especificação de persistência da extensão PHP, sem exigir a opção typeMap. A interface Persistable é análoga à interface Serializable do PHP.

Ao desserializar uma variável PHP a partir de BSON, o nome de classe codificado de um objeto Persistable substitui qualquer classe especificada na opção typeMap. No entanto, ele não substitui os tipos array, stdClass ou object.

class Person implements MongoDB\BSON\Persistable
{
    private \MongoDB\BSON\ObjectId $id;
    private \MongoDB\BSON\UTCDateTime $createdAt;
    public function __construct(private string $name)
    {
        $this->id = new \MongoDB\BSON\ObjectId();
        $this->createdAt = new \MongoDB\BSON\UTCDateTime();
    }
    public function bsonSerialize(): array
    {
        return [
            '_id' => $this->id,
            'name' => $this->name,
            'createdAt' => $this->createdAt,
        ];
    }
    public function bsonUnserialize(array $data): void
    {
        $this->id = $data['_id'];
        $this->name = $data['name'];
        $this->createdAt = $data['createdAt'];
    }
}

$collection = $client->test->persons;
$result = $collection->insertOne(new Person('Bob'));
$person = $collection->findOne(['_id' => $result->getInsertedId()]);
var_dump($person);

object(Person)#18 (3) {
    ["id":"Person":private]=>
    object(MongoDB\BSON\ObjectId)#15 (1) {
    ["oid"]=>
    string(24) "56fad2c36118fd2e9820cfc1"
    }
    ["name":"Person":private]=>
    string(3) "Bob"
    ["createdAt":"Person":private]=>
    object(MongoDB\BSON\UTCDateTime)#17 (1) {
    ["milliseconds"]=>
    int(1459278531218)
    }
}

{
  "_id" : ObjectId("56fad2c36118fd2e9820cfc1"),
  "__pclass" : BinData(128,"UGVyc29u"),
  "name" : "Bob",
  "createdAt" : ISODate("2016-03-29T19:08:51.218Z")
}

Enum Values

Você pode serializar e desserializar enums apoiados em dados BSON. Os valores de enumeração apoiados são serializados como seu valor de caso, enquanto enums puros sem valores de caso não podem ser serializados diretamente. Para executar estas conversões, você deve especificar a lógica de serialização definindo os métodos bsonSerialize() e bsonUnserialize() em sua definição de classe .

enum Role: int
{
    case USER = 1;
    case ADMIN = 2;
}

class User implements MongoDB\BSON\Persistable
{
    public function __construct(
        private string $username,
        private Role $role,
        private MongoDB\BSON\ObjectId $_id = new MongoDB\BSON\ObjectId(),
    ) {
    }
    public function bsonSerialize(): array
    {
        return [
            '_id' => $this->_id,
            'username' => $this->username,
            'role' => $this->role,
        ];
    }
    public function bsonUnserialize(array $data): void
    {
        $this->_id = $data['_id'];
        $this->username = $data['username'];
        $this->role = Role::from($data['role']);
    }
}

$collection = $client->test->users;
$result = $collection->insertOne(new User('alice', Role::USER));
$person = $collection->findOne(['_id' => $result->getInsertedId()]);
var_dump($person);

object(User)#40 (3) {
   ["username":"User":private]=>
   string(5) "alice"
   ["role":"User":private]=>
   enum(Role::USER)
   ["_id":"User":private]=>
   object(MongoDB\BSON\ObjectId)#38 (1) {
      ["oid"]=>
      string(24) "..."
   }
}