Set operator

The set operator operates on two sets of objects (or more precisely object ids).

Function ( SetExpression, SetExpression )

Function	Explanation
set_union	Returns the union of two sets of object.
set_isect	Returns the intersection of two sets of object.
set_diff	Returns the difference of two sets of object, i.e. set1 - set2.

Example

C++

set_operator.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::set_union;
  using dboo::set_isect;
  using dboo::set_diff;
  using dboo::select;
  using dboo::match;
  using dboo::eq;
  
  dboo::odb db;
  
  db.connect("localhost", 8822,
             "example_queries",
             "example_user",
             "password"s);
  
  std::vector<Purchase*> results_a;
  std::vector<Purchase*> results_b;
  std::vector<Customer*> results_c;
  
  // Selects all Purchases of milk and bread
  db.select<Purchase>(results_a, in("_product", set_union(
      select<Product>(eq("_name", "Milk"s)),
      select<Product>(eq("_name", "Bread"s)))));
  std::cout << "Found " << results_a.size() << " purchases" << std::endl;
  
  // Selects all Purchases of milk, banana and bread and price greater than 15
  db.select<Purchase>(results_b, in("_product", set_isect(
    select<Product>(dboo::in("_name", std::vector<std::string>{"Milk"s, "Bread"s, "Banana"s})),
    select<Product>(dboo::gt("_price", 15)))));
  std::cout << "Found " << results_b.size() << " purchases" << std::endl;
  
  // Selects all Customers with an a in the name but not with a .com email address
  db.select<Customer>(results_c,  set_diff(
    select<Customer>(dboo::match("_name", ".*a.*"s)),
    select<Customer>(dboo::match("_email", ".*\\.com"s))));
  std::cout << "Found " << results_c.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

init_data.cpp

Running the example will give the following output:

> ./set_operator
Found 34 purchases
Found 17 purchases
Found 0 purchases

Node.js

set_operator.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 = [];

// Selects all Purchases of milk and bread
db.query(results_a, "select<Purchase>(in(_product, set_union(\n" +
  "  select<Product>(eq(_name, 'Milk')),\n" +
  "select<Product>(eq(_name, 'Bread')))))");
console.log("Found ", results_a.length, " purchases");

// Selects all Purchases of milk, banana and bread and price greater than 15
db.query(results_b, "select<Purchase>(in(_product, set_isect(\n" +
  "  select<Product>(in(_name, {'Milk','Bread','Banana'})),\n" +
  "  select<Product>(gt(_price, 15)))))");
console.log("Found ", results_b.length, " purchases");

// Selects all Customers with an a in the name but not with a .com email address
db.query(results_c, 'select<Customer>(set_diff(\n' +
  '  select<Customer>(match(_name, ".*a.*")),\n' +
  'select<Customer>(match(_email, ".*\\\\.com")))))');
console.log("Found ", results_c.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

init_data.js

Running the example will give the following output:

> node set_operator.js
Found 34 purchases
Found 17 purchases
Found 0 purchases