Nucleoid is an open source (Apache 2.0), a runtime environment that provides logical integrity in declarative programming, and at the same time, it stores declarative statements so that it doesn’t require external database, in short it can be used as database.

Nucleoid是一个开放源代码(Apache 2.0)，它是一个运行时环境，可在声明式编程中提供逻辑完整性，同时，它存储声明性语句，因此不需要外部数据库，总之可以用作数据库。

数据结构 (Data Structure)

Data structures are defined in declarative syntax. Let’s say name is a variable, and by program requirements, name must be:

数据结构以声明性语法定义。 假设name是一个变量，并且根据程序要求， name必须为：

• less than 10 characters
  少于10个字符
• first character is upper case
  第一个字符为大写
• contains no underscore character
  不含下划线字符

so, this can be 3 separate declarations:

因此，这可以是3个单独的声明：

> if( name.length > 10 ) {
    throw "INVALID_SIZE"
  }> if( ! /[A-Z]/.test( name.charAt(0) )) {
    throw "INVALID_FIRST_CHARACTER"
  }> if( name.indexOf("_") > -1 ) {
    throw "INVALID_SPECIAL_CHARACTER"
  }

人际关系 (Relationships)

Relationships of objects are defined similar to database’s relationships, but it requires to define in declarative syntax.

对象的关系的定义与数据库的关系类似，但是需要使用声明性语法进行定义。

一对一 (One-to-One)

One-to-one’s defined as referring object’s property to another object instance.

一对一的定义是将对象的属性引用到另一个对象实例。

> class Driver {}
> class Vehicle {}> driver1 = new Driver();
> vehicle1 = new Vehicle();
> driver1.vehicle = vehicle1;

Bidirectional relationships requires additional declaration in order to keep both side synced, so not recommended unless absolutely required, associative entity may be used as alternative.

双向关系需要额外的声明才能使双方保持同步，因此除非绝对必要，否则不建议使用关联实体作为替代。

Still all the declarations are applicable to the property:

所有声明仍然适用于该属性：

> Vehicle.type = "CAR"
> driver1.vehicle.type
"CAR"

一对多 (One-to-Many)

One-to-Many is defined in three ways:

一对多定义有以下三种方式：

列在身边 (List as in One’s side)

It is a list created as property:

这是一个创建为属性的列表：

> class Customer {}
> class Order {}> Customer.orders = [];> customer1 = new Customer();
> order1 = new Order();
> customer1.orders.push(order1);

像Manys一样的财产 (Property as in Many’s side)

It is a property created, which refers to other instance:

这是一个创建的属性，它引用其他实例：

> class Employee {}
> class Project {}> employee1 = new Employee()
> project1 = new Project();
> project1.employee = employee1;

Both of first 2 options are not bidirectional.

前两个选项都不是双向的。

关联实体 (Associative Entity)

In this case, both objects will be registered in associative object:

在这种情况下，两个对象都将被注册到关联对象中：

> class User {}
> class Company {}
> class Registration {}> if ( Registrations.filter( r => r.user == User ).length > 1 ) {
    throw "USER_ALREADY_REGISTERED"
  }> user1 = new User();
> company1 = new Company();> registration1 = new Registration();
> registration1.company = company1;
> registration1.user = user1;

Having a declaration of if ( Registrations.filter( r => r.user == User ).length > 1 ){ .. } adds One-to-Many constraint. In this case, registering user1 to another company throws "USER_ALREADY_REGISTERED":

如果声明为if ( Registrations.filter( r => r.user == User ).length > 1 ){ .. }添加一对多约束。 在这种情况下，向另一家公司注册user1会引发"USER_ALREADY_REGISTERED" ：

> company2 = new Company();
> registration2 = new Registration();
> registration2.company = company2
> registration2.user = user1;
> "USER_ALREADY_REGISTERED"

多对多 (Many-to-Many)

Many-to-Many is relatively straightforward as only possible with associative entity without carrying any additional constraint.

多对多是相对直接的，只有在没有任何附加约束的情况下，才可能具有关联实体。

> class Passenger {}
> class Flight {}
> class Ticket {}> passenger1 = new Passenger();
> flight1 = new Flight();> ticket1 = new Ticket();
> ticket1.passenger = passenger1
> ticket1.flight = flight1;> flight2 = new Flight();> ticket2 = new Ticket();
> ticket2.passenger = passenger1
> ticket2.flight = flight2;

查询 (Queries)

Queries is done with functional programming.

查询是通过函数式编程完成的。

The runtime stores each instance into its class list like driver1 = new Driver() will be part of Drivers.

运行时将每个实例存储到其类列表中，例如 driver1 = new Driver() 将成为 Drivers 一部分 。

一对一 (One-to-One)

> Drivers.filter( d=> d.state == "GA").filter( d => d.vehicle.year > 2010)
// Finds drivers in GA state with car younger than 2010

一对多 (One-to-Many)

> Orders.filter( o => o.price > 100 && o.customer.id == 192)
// Finds orders with bigger than $100 prize of customer with id 192

Other direction

其他方向

> Customers.find( c=> c.id == 192).orders.filter( o=>o.price > 100)

多对多 (Many-to-Many)

Tickets.filter( t => t.passenger.id == 6912 && t.flight.destination == "LA")
// Finds ticket of passenger with id 6912 for destination to FL

Reference: https://nucleoid.org/tutorial/

参考： https : //nucleoid.org/tutorial/