从SQL Server存储过程执行Oracle存储过程(Execute an Oracle stored procedure from a SQL Server stored procedure)

 对象关系的基数定义了左端有多少个对象被映射到右端有多少个对象。 例如，它可以是： 
 
 
 
 1 : 1 （一对一） - 对于左类型的每个对象，只需要一个正确类型的对象。 在这种情况下，通常两个对象都有一个指向另一个对象的指针或存储它的唯一ID。 
 
 
 1 : 1..* （一对多） - 对于左类型的每个对象，至少需要一个正确类型的对象，但可以创建更多对象。 在这种情况下，通常左侧的对象不知道右侧的对象，但右侧的对象有一个指针或保留左侧对象的唯一ID。 
 
 
 1 : 0..1 （一个到可选的一个） - 对于左类型的每个对象，不需要任何正确类型的对象，但如果存在，则它必须不超过一个。 在这种情况下，通常左侧的对象不知道右侧的对象，但右侧的对象有一个指针或保留左侧对象的唯一ID。 
 
 
 1..* : 1..* （多对多） - 对于左类型的每个对象，至少需要一个正确类型的对象，但是一个正确类型的对象可能满足对多个对象的要求。左类型。 在这种情况下，通常左侧和右侧的两个对象都不知道其他对象，但它们都有指向常见第三个对象的指针或保留定义关系的唯一ID。 
 
 
 等等 
 
 
 请注意，虽然在我的所有示例中，我都谈到了正确的对象与左对象的关系，但每个基数都可以颠倒过来，并且一些基数指定了双向要求（即，从右到左，从左到右）。对） 
 
 以下是有关数据模型的基数的更多信息。 
 
 特别是，核心数据的上一段说明如果删除1 : 1 1 : 1..*或1..* : 1..*关系右侧的对象（换句话说，一个或多个其他对象取决于该特定对象的存在），这种关系左侧的对象将处于无效状态。 

The cardinality of an object relationship defines how many objects at the left end are mapped to how many objects at the right end. For example, it can be:
 
 
 
1 : 1 (one to one) - for each object of the left type, exactly one object of the right type is required. In this scenario, usually both objects have a pointer to the other or store the unique id of it. 
 
 
1 : 1..* (one to many) - for each object of the left type, at least one object of the right type is required, but more can be created. In this scenario, usually the object on the left does not know about the objects on the right, but the objects on the right have a pointer or keep unique id for the left object. 
 
 
1 : 0..1 (one to optional one) - for each object of the left type, no object of the right type is required, but if any exist, it must be no more than one. In this scenario, usually the object on the left does not know about the objects on the right, but the objects on the right have a pointer or keep unique id for the left object. 
 
 
1..* : 1..* (many to many) - for each object of the left type, at least one object of the right type is required, but one object of the right type might satisfy the requirement for multiple objects of the left type. In this scenario, usually both objects on the left and right side don't know about the others, but they both have a pointer to a common third object or keep unique id that defines the relationship. 
 
 
etc. 
 
 
Note that while in all my examples I talk about the relationship of the right object to the left object, each cardinality can be reversed, and some of the cardinalities specify bi-directional requirements (ie. right-to-left and left-to-right)
 
Here's more information about Cardinality with regards to data models.
 
In particular, the above paragraph from Core Data states that if you delete an object that is on the right side of a 1 : 1, 1 : 1..* or 1..* : 1..* relationship (in other words, one or more other objects depend on the existence of this particular object), the objects on the left side of such relationship would be in an invalid state.