1. Go to this page and download the library: Download dwgebler/doclite library. Choose the download type require.
2. Extract the ZIP file and open the index.php.
3. Add this code to the index.php.
<?php
require_once('vendor/autoload.php');
/* Start to develop here. Best regards https://php-download.com/ */
dwgebler / doclite example snippets
use Gebler\Doclite\{FileDatabase, MemoryDatabase};
// To create or open an existing file database.
$db = new FileDatabase('/path/to/db');
// To open an existing file database in read-only mode.
$db = new FileDatabase('/path/to/existing/db', true);
// To create a new in-memory database.
$db = new MemoryDatabase();
$users = $db->collection("user");
// Create a new User in the collection
$user = $users->get();
// Get the automatically generated document ID
$id = $user->getId();
// Set properties by magic set* methods
$user->setUsername("dwgebler");
$user->setRole("admin");
$user->setPassword(password_hash("admin", \PASSWORD_DEFAULT));
$user->setCreated(new \DateTimeImmutable);
// Update the user in the collection
$user->save();
// Retrieve this user later on by ID
$user = $users->get($id);
// Or search for a user by any field
$user = $users->findOneBy(["username" => "dwgebler"]);
class CustomUser
{
private $id;
private $username;
private $password;
public function getId() {...}
public function setId($id) {...}
public function getUsername() {...}
public function setUsername($username) {...}
}
// Retrieve a previously created user and map the result on to a CustomUser object.
// You can also pass a null ID as the first parameter to create a new CustomUser.
$user = $users->get($id, CustomUser::class);
// $user is now an instance of CustomUser and can be saved through the Collection.
$users->save($user);
use Gebler\Doclite\FileDatabase;
// Open a new database
$db = new FileDatabase('./data/mydb.db');
// Open an existing database in read-only mode
$db = new FileDatabase('./data/mydb.db', true);
// Open a new database called data.db in existing directory /home/data
$db = new FileDatabase('/home/data');
// All options - path, read-only mode, full text search, connection timeout and logger
$logger = new \Monolog\Logger('mylogger');
$db = new FileDatabase('./data/mydb.db', false, true, 1, $logger);
// Or, in PHP 8, named parameters:
$db = new FileDatabase(path: './data/mydb.db', readOnly: true, ftsEnabled: true);
use Gebler\Doclite\Exception\IOException;
use Gebler\Doclite\Exception\DatabaseException;
use Gebler\Doclite\FileDatabase;
try {
$db = new FileDatabase('/path/to/db');
} catch (IOException $e) {
var_dump($e->getMessage());
} catch (DatabaseException $e) {
var_dump($e->getMessage());
}
// Create a new, empty database
$db = new FileDatabase('/path/to/data.db');
// Import the contents of a directory where each file is a collection
$db->import('/path/to/collections', 'json', Database::IMPORT_COLLECTIONS);
// Import the contents of a directory where each sub directory is a collection
// of files representing single documents.
$db->import('/path/to/collections', 'json', Database::IMPORT_DOCUMENTS);
// Export the entire database to one file per collection in the specified
// output directory.
$db->export('/path/to/export', 'json', Database::EXPORT_COLLECTIONS);
// Export the entire database to a directory structure with one file per document.
$db->export('/path/to/export', 'json', Database::EXPORT_DOCUMENTS);
// Export only the "User" and "Person" collections.
// Assume Collection $persons = $db->get("Person");
$db->export(
'/path/to/export',
'json',
Database::EXPORT_COLLECTIONS,
['User', $persons]
);
// Return the version of DocLite as a SemVer string, e.g. 1.0.0
$db->getVersion();
$userCollection = $db->collection("Users");
$newUser = $userCollection->get();
// works for DocLite Document objects
$newUser->save();
// works for both DocLite documents and documents mapped to custom types
$userCollection->save($newUser);
$existingUser = $userCollection->get($id);
// Get a user as an object of type CustomUser.
$user = $userCollection->get($id, CustomUser::class);
// Works for DocLite Document objects.
$user->delete();
// works for both DocLite documents and documents mapped to custom types
$userCollection->deleteDocument($user);
foreach($userCollection->findAllBy(['active' => true]) as $user) {
...
}
foreach($userCollection->findAll() as $user) {
...
}
$users = $db->collection("Users");
$activeUsers = $users->where('active', '=', true)->fetch();
$gmailUsers = $users->where('email', 'ENDS', '@gmail.com')->fetch();
$registeredAndNotActiveUsers = $users->where('registered', '=', true)
->and('active', '=', false)
->fetch();
$usersInPostalArea = $users->where('address.postcode', 'STARTS', 'TE1')->fetch();
$usersWith123InPhone = $users->where('telephone', 'CONTAINS', '123')->fetch();
$usersWithNoNumbersInUsername = $users->where('username', 'MATCHES', '^[A-Za-z]*$')
->fetch();
$usersWithEditorRole = $users->where('roles[]', '=', 'EDITOR')->fetch();
$usersWithEditorOrAdminRole = $users->where('roles[]', '=', 'ADMIN')
->or('roles[]', '=', 'EDITOR')
->fetch();
$usersWithEditorAndAdminRole = $users->where('roles', '=', ['ADMIN', 'EDITOR']);
$usersWhoHaveAtLeastOneRoleWhichIsNotAdmin = $users->where('roles[]', '!=', 'ADMIN')->fetch();
/*
* This next one is trickier. "roles" is a list of values in our document.
* As we can see above, roles[] != ADMIN would return all users who
* have at least one role in their list which is not ADMIN.
* But this means if a user has roles ["USER","ADMIN"], they would
* be matched.
* So for users who do NOT have the ADMIN role at all, we can
* quote the value "ADMIN" and ask for matches where the entire list of roles
* (so no square brackets) does not contain this value.
*/
$usersDoNotHaveAdminRole = $users->where('roles', 'NOT CONTAINS', '"ADMIN"')->fetch();
$deleteAllUsersWithEditorRole = $users->where('roles[]', '=', 'EDITOR')->delete();
$first10UsersOrderedByFirstName = $users->orderBy('first_name', 'ASC')
->limit(10)
->fetch();
$next10UsersOrderedByFirstName = $users->orderBy('first_name', 'ASC')
->limit(10)
->offset(10)
->fetch();
// Use [] on any field which is a list to search within its sub-items
$usersWithPostAccessToPagesApi = $users->where(
'api_access./v1/pages/[]', '=', 'POST')->fetch();
$allUsersWithPostAccessToAnyApi = $users->where('api_access[]', '=', 'POST')
->fetch();
$start = new DateTimeImmutable('2021-03-01 00:00:00');
$end = new DateTime('2021-06-30');
$usersWhoSignedUpBetweenMarchAndJune = $users->where('date', 'BETWEEN', $start, $end)->fetchArray();
/**
* Nested queries are also possible.
* To get all users where
* (active=true and address.postcode matches '^[A-Za-z0-9 ]*$')
* OR
* (roles[] list contains "EDITOR" and lastLogin > 2021-01-30)
*/
$nestedUsers = $users->where('active', '=', true)
->and('address.postcode', 'MATCHES', '^[A-Za-z0-9 ]*$')
->union()
->where('roles[]', '=', 'EDITOR')
->and('lastLogin', '>', '2021-01-30')
->fetch();
/**
* Imagine a user document like:
* {"__id":"1", "name":"John Smith"}
*
* and a corresponding comments document like:
* {"__id":"5", "user_id": "1", "comment":"Hello world!"}
*
* You can query the users collection with a join to retrieve an aggregated document like this:
* {"__id":"1","name":"John Smith","comments":[{"__id":"5","comment":"Hello world!"}]}
*/
$users = $db->collection('Users');
$comments = $db->collection("Comments");
$users->where('__id', '=', '1')->join($comments, 'user_id', '__id')->fetchArray();
$userCollection->enableCache();
// Set the cache validity period to 1 hour.
$userCollection->setCacheLifetime(3600);
$userCollection->disableCache();
$userCollection->clearCache();
$collection = $db->collection("Users");
$collection->beginTransaction();
// ...do some stuff, insert a bunch of records or whatever...
// commit the results and end the transaction
$collection->commit();
// or rollback the changes and end the transaction
$collection->rollback();
$users = $db->collection("Users");
// Create a new Document with an auto generated UUID.
$user = $db->get();
// Create a new property called username via a magic setter.
$user->setUsername('dwgebler');
// Create a new property called password via a magic property.
$user->password = password_hash("admin", \PASSWORD_DEFAULT);
// Read the username property via a magic property.
echo $user->username;
// Read the password property via a magic getter.
echo $user->getPassword();
// Properties can contain scalar values, arrays, or even other Documents and
// custom objects.
$user->setRoles(['user', 'admin']);
// setter uses camel case
$user->setFirstName('Dave');
// but the corresponding property created will be lower cased and snake_cased
echo $user->first_name;
// if you want a key in a document to be case sensitive, set it as a property only
$user->FirstName = 'Dave';
// you should now use the property access to retrieve its value later on
echo $user->FirstName;
// This will not work and will raise a ValueError on getFooBar(),
// because the method call will look for a property called foo_bar
$user->FooBar = 'baz';
$user->getFooBar();
// This is the same as:
// $address = $user->getAddress();
// $postcode = $address['postcode'];
$user->getValue('address.postcode');
// Assume "roles" is a list, this will return an array
$user->getValue('roles');
// Retrieve the first role
$user->getValue('roles.0');
// Assume api_access is a dictionary of keys mapped to lists.
// This will return the list of data under the /v1/users/ key
// as an array.
$access = $user->getValue('api_access./v1/users/');
if (!in_array('POST', $access)) { ... }
// If address does not exist, it will be created with postcode as a key.
$user->setValue('address.postcode', 'TE1 3ST');
// Or set a value with special characters in the name:
$user->setValue('api_access./v1/users/', ['GET', 'POST']);
class Person
{
private $id;
private $firstName;
private $lastName;
private $address = [];
private $postcode;
private $dateOfBirth;
private $identityVerified;
public function getId(): ?int
{
return $this->id;
}
public function setId(string $id): self
{
$this->id = $id;
return $this;
}
public function getFirstName(): ?string
{
return $this->firstName;
}
public function setFirstName(string $firstName): self
{
$this->firstName = $firstName;
return $this;
}
public function getLastName(): ?string
{
return $this->lastName;
}
public function setLastName(string $lastName): self
{
$this->lastName = $lastName;
return $this;
}
public function getAddress(): ?array
{
return $this->address;
}
public function setAddress(array $address): self
{
$this->address = $address;
return $this;
}
public function getPostcode(): ?string
{
return $this->postcode;
}
public function setPostcode(string $postcode): self
{
$this->postcode = $postcode;
return $this;
}
public function getDateOfBirth(): ?\DateTimeImmutable
{
return $this->dateOfBirth;
}
public function setDateOfBirth(\DateTimeImmutable $dateOfBirth): self
{
$this->dateOfBirth = $dateOfBirth;
return $this;
}
public function getIdentityVerified(): ?bool
{
return $this->identityVerified;
}
public function setIdentityVerified(bool $identityVerified): self
{
$this->identityVerified = $identityVerified;
return $this;
}
}
$user = $collection->get("b83e319a-7887-11eb-8deb-b9e03d2e720d");
$user->map('person', Person::class);
// $user->getPerson() now returns a Person object.
// Or you can map to an existing Person object.
$person = new Person();
$user->map('person', $person);
$users = $db->collection("Users");
// Create a new Document with an auto generated UUID.
$user = $users->get();
// $date is a \DateTimeImmutable
$date = $user->getTime();
echo $date->format('d m Y H:i');
$users = $db->collection("Users");
// Create a new Document with a custom ID.
// If this ID already exists in the Users collection, that document will be returned.
$user = $users->get("user_3815");
$users = $db->collection("Users");
// Create a new document with an automatically generated UUID and
// retrieved as an object of type CustomUser.
$user = $users->get(null, CustomUser::class);
$user->setUsername("admin");
$users->save($user);
$users = $db->collection("Users");
// Create a new document with an automatically generated UUID and
// retrieved as an object of type CustomUser.
$user = $users->get("12345", CustomUser::class);
$users->deleteDocument($user);