Value comparator

The value comparator matches a field against a value.

ValueComparator ( FieldExpression, ValueExpression )

Function	Explanation
eq	Include objects where the compared field is equal to value expression.
neq	Include objects where the compared field is not equal to value expression.
gt	Include objects where the compared field is greater than value expression.
lt	Include objects where the compared field is lower than value expression.
gte	Greater than or equals
lte	Lower than or equals
match	For string fields only, the value expression is a regular expression.

Example

C++

value_comparator.cpp

Try it

#include "types.h"

#include <dboo/rfx.h>
#include <dboo/odb.h>

#include <vector>
#include <memory>

int main() {
  dboo::init();
  
  using namespace std::string_literals;
  
  using dboo::eq;
  using dboo::gt;
  using dboo::gte;
  using dboo::lte;
  using dboo::set_union;
  using dboo::match;
  using dboo::select;
  
  dboo::odb db;
  
  db.connect("localhost", 8822,
             "example_queries",
             "example_user",
             "password"s);
  
  std::vector<Product*> results_a;
  std::vector<Purchase*> results_b;
  std::vector<Customer*> results_c;
  std::vector<Customer*> results_d;
  std::vector<Customer*> results_e;
  
  // Selects all Product with _price greater than 10.5
  db.select<Product>(results_a, gt("_price", 10.5));
  std::cout << "Found " << results_a.size() << " products" << std::endl;
  
  // Selects all Purchase with quantity = 10
  db.select<Purchase>(results_b, eq("_quantity", 10));
  std::cout << "Found " << results_b.size() << " purchases" << std::endl;
  
  // Selects all Customer with a .com email address:
  db.select<Customer>(results_c, match("_email", ".*@.*\\.com"s));
  std::cout << "Found " << results_c.size() << " customers" << std::endl;
  
  // Selects all Customer with email exactly matching "user@someemail.somewhere"
  db.select<Customer>(results_d, eq("_email", "op6732@p12.com"s));
  std::cout << "Found " << results_d.size() << " customers" << std::endl;

  // Selects all Purchases with products priced lower than or equal to 5 or greater than or equal to 10.
  std::vector<std::unique_ptr<Purchase>> results_up;
  db.select<Purchase>(results_up, in("_product", set_union(
    select<Product>(gte("_price", 10)),
    select<Product>(lte("_price", 5)))));
  std::cout << "Found " << results_up.size() << " purchases" << std::endl;
  
  return 0;
}

types.h

#include <dboo/rfx.h>

class Purchase;
class Customer {
public:
  Customer() = default;
  Customer(const std::string& name, const std::string& email) : _name{name}, _email{email} {}
  inline static dboo::cls<Customer> cls{"Customer"};
  static void dboo_class_init(dboo::cls<Customer>& c) {
    c.member(&Customer::_email, "_email");
    c.member(&Customer::_name, "_name");
    c.member(&Customer::_purchases, "_purchases");
  }

  void made_purchase(Purchase* purchase) {
    _purchases.emplace_back(purchase);
  }
  
private:
  std::string _email;
  std::string _name;
  std::vector<Purchase*> _purchases;
};

class Product {
public:
  Product() = default;
  Product(const std::string& name, double price) : _name{name}, _price{price} {}
  inline static dboo::cls<Product> cls{"Product"};
  static void dboo_class_init(dboo::cls<Product>& c) {
    c.member(&Product::_name, "_name");
    c.member(&Product::_description, "_description");
    c.member(&Product::_price, "_price");
  }
  double price() const { return _price; }
private:
  std::string _name;
  std::string _description;
  double _price{0.};
};

class Purchase {
public:
  Purchase() = default;
  Purchase(Product* prod,
           Customer* cust,
           double quantity, double price )
    : _product{prod}
    , _customer{cust}
    , _quantity{quantity}
    , _price{price}
  {}
  virtual ~Purchase() = default;
  inline static dboo::cls<Purchase> cls{"Purchase"};
  static void dboo_class_init(dboo::cls<Purchase>& c) {
    c.member(&Purchase::_customer, "_customer");
    c.member(&Purchase::_product, "_product");
    c.member(&Purchase::_price, "_price");
    c.member(&Purchase::_quantity, "_quantity");
  }

private:
  Product* _product = nullptr;
  Customer* _customer = nullptr;
  double _quantity{0.};
  double _price{0.};
};

To create the database and initialize example data:

init_db.cpp

Try it

init_data.cpp

Try it

Running the example will give the following output:

> ./value_comparator
Found 5 products
Found 4 purchases
Found 1 customers
Found 1 customers
Found 88 purchases

Node.js

value_comparator.js

Try it

const dboo = require('dboo')
const types = require('./types')

dboo.init();

const db = new dboo.odb();
  
db.connect("localhost", 8822,
    "example_queries",
    "example_user",
    "password");

let results_a = [];
let results_b = [];
let results_c = [];
let results_d = [];
let results_e = [];
  
// Selects all Product with _price greater than 10.5
db.query(results_a, "select<Product>(gt(_price, 10.5))");
console.log("Found ", results_a.length, " products");
  
// Selects all Purchase with quantity = 10
db.query(results_b, "select<Purchase>(eq(_quantity, 10))");
console.log("Found ", results_b.length, " purchases");

// Selects all Customer with a .com email address:
db.query(results_c, 'select<Customer>(match(_email, ".*@.*\\.com"))');
console.log("Found ", results_c.length, " customers");

// Selects all Customer with email exactly matching "user@someemail.somewhere"
db.query(results_d, 'select<Customer>(eq(_email, "op6732@p12.com"))');
console.log("Found ", results_d.length, " customers");

// Selects all Purchases with products priced lower than or equal to 5 or greater than or equal to 10.
db.query(results_e, 'select<Purchase>(in(_product, set_union(select<Product>(gte(_price, 10)),select<Product>(lte(_price, 5)))))');
console.log("Found ", results_e.length, " customers");

types.js

const dboo = require('dboo')

class Product {
  _name;
  _description;
  _price;
  constructor(name = "", price = 0.) {
    this._name = name;
    this._price = price;
  }
};
exports.Product=Product;

class Purchase {
  _customer;
  _product;
  _price;
  _quantity;
  constructor(prod = null, customer = null, quantity = 0, price = 0) {
    this._customer = prod;
    this._product = customer;
    this._price = quantity;
    this._quantity = price;
  }
};
exports.Purchase=Purchase;

class Customer {
  _email;
  _name;
  _purchases;
  
  constructor( name = "", email = "") {
    this._name = name;
    this._email = email;
    this._purchases = [];
  }
  
  made_purchase(purchase) {
    this._purchases.push(purchase);
  }
};
exports.Customer=Customer;


dboo.class(Product, [
  {"_name":dboo.string},
  {"_description":dboo.string},
  {"_price":dboo.double},
]);

dboo.class(Purchase, [
  {"_customer":Customer},
  {"_product":Product},
  {"_price":dboo.double},
  {"_quantity":dboo.double},
]);

dboo.class(Customer, [
  {"_email":dboo.string},
  {"_name":dboo.string},
  {"_purchases":dboo.array(Purchase)},
]);

To create the database and initialize example data:

init_db.js

Try it

init_data.js

Try it

Running the example will give the following output:

> node value_comparator
Found  5  products
Found  4  purchases
Found  1  customers
Found  1  customers
Found  88  customers

DBOO manager

# Using dboo manager from command line:
> dboo example_queries -u=example_user -p=password -- "select<Product>(gt(_price, 10.5))"
{"dboo::objectid" : "4a00887c09c8000e", "dboo::class" : "Product", "_name" : "Milk", "_description" : "", "_price" : 14.949999999999999}
{"dboo::objectid" : "4a00887c09c80010", "dboo::class" : "Product", "_name" : "Bread", "_description" : "", "_price" : 28.949999999999999}
{"dboo::objectid" : "4a00887c09c80011", "dboo::class" : "Product", "_name" : "Juice", "_description" : "", "_price" : 34.950000000000003}
{"dboo::objectid" : "4a00887c09c80012", "dboo::class" : "Product", "_name" : "Banana", "_description" : "", "_price" : 20}
{"dboo::objectid" : "4a00887c09c80013", "dboo::class" : "Product", "_name" : "Biscuits", "_description" : "", "_price" : 23.949999999999999}