Hi Derek

I do not think that E. Codd invented significant mathematical theories, butI think he's done some things that need to be classified as applied mathematics (relational algebra, functional dependencies). He, along with others began to establish this theory of databases as a mathematical theory. This paved the further development of the theory of databases as science.



1. Before I give you a definition of the surrogate key, I would like to say that surrogate key is not the main thing here. The main thing here is the decomposition into the binary (atomic) structures. This is crucial not only for database theory but also in some other areas.

So far in this thread, I gave examples showing that the surrogate key does not work. Some of these examples show that the surrogate key can not be used for over 90% of business applications. These examples were more of practical character, that is, they were not theoretical.

Now I would like to present some theoretical problems related to RM and RM/T which are very serious. I will try to present it as much as it is possible on the user group. First, E. Codd did this decomposition of relations into binary relations, without any prove. Let me now give you examples which are of the theoretical character and which show that RM cannot solve some serious problems. These problems form a large field in the theory of databases.
Example A:
State1. Person X from a company that supplies consumers with electricity reads a device for measuring the energy consumption for a person Y. Person Xwrites down on paper that, on May 1st, 2011, person Y fully spent 128 units of energy.
State2. Person X submits this list to the IT department on June 1st, 2011, a month later.
State3. The person from the IT department has put this list in a drawer and
State4. Thus, the data was entered into the database on September 1st, 2011..
State5. Then the IT department filed a lawsuit against a person Y, because this person has not paid the electricity consumed.
State6. However, it turns out person Y passed away on May 15th, 2011.
State7. During the trial it is determined that the person who entered the data, made a mistake and entered 728 instead of 128 (as the amount of energyconsumed).
The son of person Y is a good lawyer represents in court his late father.

This kind of problems cannot be solved using the RM / T. It cannot be solved using the RM (or others db models). Of course, for this kind of problems, the decomposition into binary relationships with surrogates, what is demonstrated by Codd, does not work at all.

This set of problems is solved for the first time in 2005, and this is my solution, which is presented in this user group in 2005.

If you want to see how to do the decomposition into binary structures for these cases, then please see my post from February 13, 2013, see second case..
In my post which is from February 13, 2012. I explained the problems that General databases can solve, while Simple databases cannot solve these problems. I use the term "General database theory" (General databases as shortcut) for the group of database’s fields that I roughly presented in my postfrom 13 February, 2013 in this thread.

Keep in mind that "General databases" does not have Delete and Update operations. So, there are no Delete anomalies or Update anomalies. The purpose of General database is to keep all the data that are entered into it. Therefore there are no Insert anomalies.

I would like to emphasize that the paper "RM/T" has so many practical and theoretical errors that it is scandalous that the paper was published.


I take the definition of surrogate from RM/T. This is the only official definitions of Codd about the surrogate key.
By the way, today I visited the site which is related to the surrogate key on Wikipedia. It is really sad what some people write.




In this example, I have two identifiers, both belonging to one database structure. The first identifier identifies a real object car; while the secondidentifier identifies an abstract object that is a state of this car. Everything else in this relation represents the knowledge about one attribute. Once again, notice that the state of an object is an abstract object. For example, you can not touch the state, while the object car you can.
A state of an entity, I have defined as any knowledge about that entity, which has some subject. As I said, these two identifiers are linked and are located in one database structure, which I call the state of an entity. The identifier of the state identifies the state of the entity, but can not identify the entity. The identifier of the entity identifies the entity, but can not identify a state of the entity. However, the state structure connects these two identifiers. This is my solution, which connects the identification of an abstract object with the identification of the real object, and vice verse.


Obviously, my solution is not a surrogate.


Joe and David are IT professionals. I have also in the past in some way insulted these guys, but now I know, it was my mistake.

I've already explained to you, the industry-standard identifiers are the same type as my identifiers. More than 90% of all business applications use these identifiers.
You and I are discussing at the level of "db designer - database". Joe talks about “the industry-standard, externally verifiable keys with known validation rules”. It is not possible externally check the surrogates.
The question is how a police officer can check a license, using the "RM / T"? In order that an officer might check the passport of a traveler, how should be implemented "RM / T"? In order to use ATMs, how should be implemented "RM / T"?
There is another important question here. How the logical and semantic content is conveyed between a db and user. Using surrogates this is not possible. In RM/T this is possible only between db designer and a database.

Since Anchor Modeling and RM /T use surrogates, it is clear that the damageis global. I want to show you the extent of the damage, which occurs with implementation of the RM / T into industry and science.



Up in this thread, I explained that I took this example because it is similar to the example from the book of C. Date. I was surprised with the db design in Date's book. In the example I wanted to show the following:

1. RM / T can not work with Nulls at all.
2. If someone is working with Nulls then he should be aware that does nothelp Codd's recommended three-value logic at all.
3. The surrogate key should be never displayed.
4. It is shown that the binary relation with Nulls looks really bad and it would be best to forbid the work with Nulls, especially because the user cannot see the primary key (that is surrogate key) of the binary relation.
5. Where and how to keep the uncompleted data?
6. If one instead of surrogate key uses VIN number (that is industry-standard key), then he can do it fairly.

Vladimir Odrljin

In my post on February 19, 2013 I made a typo at ExampleA. This is a corrected version.


I do not think that E. Codd invented significant mathematical theories, butI think he's done some things that need to be classified as applied mathematics (relational algebra, functional dependencies). He, along with others began to establish this theory of databases as a mathematical theory. This paved the further development of the theory of databases as science.



1. Before I give you a definition of the surrogate key, I would like to say that surrogate key is not the main thing here. The main thing here is the decomposition into the binary (atomic) structures. This is crucial not only for database theory but also in some other areas.

So far in this thread, I gave examples showing that the surrogate key does not work. Some of these examples show that the surrogate key can not be used for over 90% of business applications. These examples were more of practical character, that is, they were not theoretical.

Now I would like to present some theoretical problems related to RM and RM/T which are very serious. I will try to present it as much as it is possible on the user group. First, E. Codd did this decomposition of relations into binary relations, without any prove. Let me now give you examples which are of the theoretical character and which show that RM cannot solve some serious problems. These problems form a large field in the theory of databases.
Example A:
State1. Person X from a company that supplies consumers with electricity reads a device for measuring the energy consumption for a person Y. Person Xwrites down on paper that, on May 1st, 2011, person Y fully spent 128 units of energy.
State2. Person X submits this list to the IT department on June 1st, 2011, a month later.
State3. The person from the IT department has put this list in a drawer andforgotten about it. After two months, he was reminded of this list and promptly handed it over to the person doing data entry.
State4. Thus, the data was entered into the database on September 1st, 2011..
State5. Then the IT department filed a lawsuit against a person Y, because this person has not paid the electricity consumed.
State6. However, it turns out person Y passed away on May 15th, 2011.
State7. During the trial it is determined that the person who entered the data, made a mistake and entered 728 instead of 128 (as the amount of energyconsumed).
The son of person Y is a good lawyer represents in court his late father.

This kind of problems cannot be solved using the RM / T. It cannot be solved using the RM (or others db models). Of course, for this kind of problems, the decomposition into binary relationships with surrogates, what is demonstrated by Codd, does not work at all.

This set of problems is solved for the first time in 2005, and this is my solution, which is presented in this user group in 2005.

If you want to see how to do the decomposition into binary structures for these cases, then please see my post from February 13, 2013, see second case..
In my post which is from February 13, 2012. I explained the problems that General databases can solve, while Simple databases cannot solve these problems. I use the term "General database theory" (General databases as shortcut) for the group of database’s fields that I roughly presented in my postfrom 13 February, 2013 in this thread.

Keep in mind that "General databases" does not have Delete and Update operations. So, there are no Delete anomalies or Update anomalies. The purpose of General database is to keep all the data that are entered into it. Therefore there are no Insert anomalies.

I would like to emphasize that the paper "RM/T" has so many practical and theoretical errors that it is scandalous that the paper was published.



I take the definition of surrogate from RM/T. This is the only official definitions of Codd about the surrogate key.
By the way, today I visited the site which is related to the surrogate key on Wikipedia. It is really sad what some people write.



In this example, I have two identifiers, both belonging to one database structure. The first identifier identifies a real object car; while the secondidentifier identifies an abstract object that is a state of this car. Everything else in this relation represents the knowledge about one attribute. Once again, notice that the state of an object is an abstract object. For example, you can not touch the state, while the object car you can.
A state of an entity, I have defined as any knowledge about that entity, which has some subject. As I said, these two identifiers are linked and are located in one database structure, which I call the state of an entity. The identifier of the state identifies the state of the entity, but can not identify the entity. The identifier of the entity identifies the entity, but can not identify a state of the entity. However, the state structure connects these two identifiers. This is my solution, which connects the identification of an abstract object with the identification of the real object, and vice verse.


Obviously, my solution is not a surrogate.


Joe and David are IT professionals. I have also in the past in some way insulted these guys, but now I know, it was my mistake.

I've already explained to you, the industry-standard identifiers are the same type as my identifiers. More than 90% of all business applications use these identifiers.
You and I are discussing at the level of "db designer - database". Joe talks about “the industry-standard, externally verifiable keys with known validation rules”. It is not possible externally check the surrogates.
The question is how a police officer can check a license, using the "RM / T"? In order that an officer might check the passport of a traveler, how should be implemented "RM / T"? In order to use ATMs, how should be implemented "RM / T"?
There is another important question here. How the logical and semantic content is conveyed between a db and user. Using surrogates this is not possible. In RM/T this is possible only between db designer and a database.

Since Anchor Modeling and RM /T use surrogates, it is clear that the damageis global. I want to show you the extent of the damage, which occurs with implementation of the RM / T into industry and science.


Up in this thread, I explained that I took this example because it is similar to the example from the book of C. Date. I was surprised with the db design in Date's book. In the example I wanted to show the following:

1. RM / T can not work with Nulls at all.
2. If someone is working with Nulls then he should be aware that does nothelp Codd's recommended three-value logic at all.
3. The surrogate key should be never displayed.
4. It is shown that the binary relation with Nulls looks really bad and it would be best to forbid the work with Nulls, especially because the user cannot see the primary key (that is surrogate key) of the binary relation.
5. Where and how to keep the uncompleted data?
6. If one instead of surrogate key uses VIN number (that is industry-standard key), then he can do it fairly.

Vladimir Odrljin

A. Now I would like to separate this subject, and to give it the appropriate title. I think this will help a better understanding of this very complex matter.

How a database stores an object and how a database can remember of its objects?

So how the stuff work? Is there a general algorithm that manages the objects in the database? Such an algorithm should have the following steps:

First, I will define the basic concepts. In the database, each object was selected using a procedure which performs the identification of this object.Each object in the database has its identifier.
All objects stored in the databases are treated as abstract objects. In thegeneral case, we have the following three kinds of abstract objects:

1. The abstract object that represents a real object. In this case, the real
object and the corresponding abstract object in the database have the
same identifier.
2. This kind of abstract object is the result of the human imagination. (for
example horse Pegasus, Mickey Mouse etc.). These abstract objects do
not represent the real objects.
I wrote about these objects; see my comments on November 28, 2007 on
this user group.
3. These are abstract objects, which do not represent real objects, but they
represent some specific abstraction of the real objects. For example, a
s state of an entity is one such abstract object.
This kind of abstract object is a special database structure. This
structure
contains the corresponding identifiers that determine the identification of
the abstract object. The structure has link between the corresponding
identifiers.
The main part of my model are the states: the state of an entity (object)
and the state of a relationship. In my previous post I explained, howto
realize the identification of the abstract object, that is, how to identify
the state of an entity.

Here it is shown that this is the identification of abstract objects in my db model. And in my model there are only the states. However, entities, relationships, attributes, and states are fairly general terms. It is very important that in my model, knowledge is associated with attributes, objects, relationship and condition.
Note that the abstract objects are well defined in my model. I wrote about the abstract object in my papers. For example see my paper “Semantic databases and semantic machines�, section 1 at http://www.dbdesign11.com
I introduce m-attributes, m-entities, m-relationships and m-states. These objects are interpretations and abstractions of their corresponding real world objects. I name them abstract objects. Note that the four mentioned “m� objects are objects of a most general character.

Properties of abstract objects are:
(i) Abstract objects are recorded, meaning that they are permanent.
(This implies that abstract objects need a language.)
(ii) Abstract objects hold meaning for corresponding subjects.
(iii) Abstract objects differ in the way they are constructed.
1. The simplest of them – m-attributes, are direct abstractions of the
real world through our perceptual abilities.
2. More complex abstract objects are constructed from simpler ones.
For instance, m-entities are constructed from m-attributes.

Therefore, hierarchy among abstract objects is determined by the
level of abstraction of their corresponding real world objects.

(iv) We identify abstract objects through their identifiers.


Here in this post I'm trying to write a little more about the identification. In connection with the identification I have done some other things besides this written in here. I'll mention the identification of attributes, entities, relationship and states. See my post “ Does the phrase " Russell's paradox " should be replaced with another phrase? � .
Also see my paper “Semantic databases and semantic machines� section 5.6


B. Here is another example with regard to low theoretical level in RM/T.E.Codd often did the transition from ER model into RM model and vice versa.. He works with the entities, associations and relations, but he did not show how it works these transitions between data models. He did not even notice that he has to explain and prove it.
If you want to see how to build a theory of the mapping between data models, then you can refer to the works of other authors. (for example, see Ron Fagin, Phil Bernstein, S. Alagić, S. Melnik, …)
You can see my solution for the mapping between data models, in my post of February 13, 2013, see 11th case.

C. The identifiers defined in my solution are the keys, because they belong to objects. They belong to the real objects or they belong to the abstract objects.
The surrogates don't belong to a real objects, so, as Derek noticed they are in contradiction with the definition of the relation keys.

Note that key defined in my solution is general solution. Surrogate key is just a special case. Key defined in my solution can do the following:
(i) My key can do what the surrogate key can.
(ii) My key can do what the surrogate key can not. (For example, my key is able to identify the states and can maintain a "history."
When we work with surrogates, it may happen that two surrogate keys have all the same attributes. My key can maintain this case.)

With this my message I wanted to show that surrogates are just "technical detail", but that there are other things which are more important.

Vladimir Odrljin

Dana ponedjeljak, 11. velja�e 2013. 08:41:14 UTC+1, korisnik Derek Asirvadem napisao je:


1. I would like to mention that this part which is about the surrogate keyis not important, it's maybe 5% of the problem. Decomposition of a structure into binary structures is what is important here. Atomic structures imply many important consequences. Some of these important consequences are atomic semantics and atomic sentences.
E. Codd and Date & Darwen, is a group that has been extensively and unsuccessfully worked on the problem of decomposition of structures into binary structures.
The decomposition of structures in the binary structures, which is shown inthe work of the RM / T is not correct because it is only valid for Simple databases. These are databases which maintain only current state. RM / T isnot correct for databases that maintain history of events. RM / T also does not hold for General database theory. ( The basic ideas of General database theory, I've outlined in this thread in my post of 13 February 2013. )
In my papers it is shown how to construct the aforementioned decomposition for the following databases: Simple databases, General databases, databasesthat implement RM, databases that implement ER Model and databases that implement file systems. It is also shown how to do the mapping between these data models.

Codd is introduced surrogates only for one reason. By using the surrogates he tried to get binary (atomic) structures.

2. RM / T "solution" is not supported with theory. For example, in the RM / T paper, binary decomposition is not proven at the level of ER Model. It was not proven in RM/T paper that this decomposition into the binary structures is valid in the ER model. Codd introduced the E and P atomic structures, directly into the ERM without any evidence, because he needed the binarystructures. I would say that he desperately needs the binary decompositionbecause this decomposition means "A and Z" of RM/T. Then Codd immediatelyproclaimed the binary structures of ERM as binary relations. Thus he introduced the E and P relations. By the way this is not science; even more, in my opinion, this is not a “discipline� as C. Date presents RM/T.
If one wants to transfer the binary structure from ERM in RM (and also do inverse mapping), then it has to do with a theory about the mapping between the two data models. As I already wrote about it, Codd did not notice it atall.

3. The RM / T, section 4, Codd wrote: "There are three Difficulties in employing user-controlled keys as permanent surrogates for entities."
My comment: The surrogates are not user-controlled by definition.

Also in RM / T, section 4, Codd wrote: "Introduction of the E-domain, E-attributes and surrogates does not make a user controlled keys obsolete. Userswill often need entity identifiers (such as part serial numbers) that are totally under their control, although they are no longer compelled to invent a user-controlled key if they do not whish to. "
My comment: the surrogates are not user-controlled by definition.

4. It is not clear what the surrogate key is. Does the surrogate key is a part of a theory or is a technical solution? Does the surrogate key is a part of an entity? Codd also need to explain why leaves relational key.
It is not clear what Codd modeled by using a surrogate key? Note that RM/T is data model. What RM/T describes and explains? Does "RM / T� model real things?

States of the entities are modeled in my solution, for example. The entities and relationships are from the real world.
I also introduced abstract objects, which I defined precisely. In working with abstract objects, the main tool is the identification. How the memory of the database operates with abstract objects and how memory identifies abstract objects is an important part in my paper. So, in my theory about the identification, identifiers (labels, tokens) have important roles, especially in memory.

5. What is done by Codd in his paper "RM / T"? He was aware that the binary relation must have a simple key. If the key is composite then there is nopoint to create a binary relation, which has a key with many attributes. So, Codd introduced a simple key. He understood that surrogate keys can cause problems. Therefore, he has introduced some additional things - he proposed the surrogate key should be invisible to the user.
He was also aware that if someone solves this decomposition into binary structures, then these binary structures must have a simple key and one attribute. So any new solution must be plagiarism. Obviously this approach is very useful and cheap.

There is another approach to this problem. It is 6nf. However 6nf has one big minus. Authors of 6nf not give a procedure that places a relvar in 6nf. Note that the authors of 6nf here actually trying to solve the aforementioned binary (atomic) decomposition.

At this User Group, I gave an example of the relation whose attributes are mutually independent. This example shows that 6nf is absurd, because there are relations who are in 6nf, but these relations have keys that are composed of a large number of attributes. Theoretically the number of these attributes can be any finite number.

6. Construction of the surrogate key.

The RM / T relation has a primary key, which is usually a composite key. A primary key is in the database and has the corresponding attributes in the real world.

In addition to this primary key, Codd has added another primary key, which is only in the database, it is a surrogate key. In this way, there are two primary keys on the database level and the corresponding attributes are at the third level, that is, at the level of the corresponding real entity.
As I already wrote, Codd is introduced surrogates only for one reason. By using the surrogates he tried to get binary (atomic) structures.

Can you imagine how easily an experienced programmer can create chaos if heintentionally changing the value of a key in one of these aforementioned three levels?

To make matters better the surrogates are used only as part of binary structures.
So, to escape work with the two parallel relational databases, Codd uses only binary relations. But now new problems arise. These problems are caused by the surrogate key. I will mention the following two such problems:
(i) How to identify an entity in the real world using a surrogate key from a database? Note that the surrogate key does not exist in the real world.. We note also that in RM / T, we work only with binary relations.
(ii) Two distinct entities can have the same state. This impies the following problem: How to find the two corresponding real world objects. Note that a key in the RM is on the level of relation and a key in RM/T is on the level of a database. The same problem exist in OOA. Note that the surrogatekey is similar to OO identifier.

7. In my solution, the real entity has the (real) identifier. This identifier also exists in the corresponding database structure. So this identifieris not a surrogate key, even more it is not a key in my solution.
Note that my structure has the identifier of state as primary key. The identifier of state is different from identifier of an entity.

8. Note that Codd does not understand the difference between the surrogatekey and externally verifiable key. See 3, above. There are two types of externally verifiable keys. The first is the global industry-standard externally verifiable keys. Another type is not as the global industry-standard; rather it is the local-standard externally verifiable keys.
The local standard is very important because it gives a great opportunity for good design.
One example is employee number at some company. A company can maintain a list of the employee numbers on the paper at Human Resources, or a company can maintain a documentation or a company can put it on the web with limited access, etc. Thus all departments can use these numbers. It is important that a user can find and verify the identity in the real world, it is not necessary that the employee numbers be part of the real employee. Off course acompany can associate badges to employees, if they want it.
Another example about local standard is addresses. Different countries havedifferent systems of addresses, but an address can externally be verified.

It is very important to understand that each company may have its own system of identification and technology, which can be public or private and it can be externally verifiable. The Local standard is an example of the good design. Of course, general industry-standard keys and local-standard keys are not surrogates. Note that there is a profound difference between the externally verifiable keys and surrogates keys. Surrogates are on the level ofthe link “db designer–database�, while externally verifiable keys are on the level of the link "users-database".
The surrogates are related to the memory manipulation, while externally verifiable keys are related to the transfer of the semantic and logical content. It seems to me that Codd did not understand the nature of this problem?

9. The following paper was selected as the best paper of ER’09 :
Anchor Modeling - An Agile Modeling Technique Using the Sixth Normal Form for Structurally and Temporally Evolving Data.
This paper, among others, has three important parts: the surrogate key fromthe RM / T, 6nf, and the main results of my paper published in the 2005th.In this post I showed that the RM / T is not correct, i.e. its binary decomposition is not correct. RM/T was not resolved problems in the domain of the general theory of databases. In contrast to RM/T paper, these problems are solved in my papers.
I have also shown that 6nf has no scientific value. Paper "Anchor Modeling"promotes the RM / T and 6nf, in conjunction with the most important results in database theory, although these works are incorrect and inaccurate concerning important parts of the general theory of databases. So among these three important parts of "Anchor Modeling" only accurate part is the one whose results I published four years before the paper "Anchor Modeling."
One of the main purposes of normalization in RM is to avoid redundancy. In contrast to RM my model keeps all redundancy. This shows that the difference between my model and the RM is complete. There are other differences between my model and RM, which indicates that these two models are the opposite.. Therefore, the aforementioned "bridging" between RM and my model is not correct.

10. I wrote such a long post primarily to protect my work. But also this post was written, because people debating for years on this subject and in myopinion spend a great time on things that are not clearly presented.
Of course, everyone is entitled to their opinion.

Vladimir Odrljin

Dana ponedjeljak, 11. velja�e 2013. 08:41:14 UTC+1, korisnik Derek Asirvadem napisao je:


Hi Derek,


(a) Codd defined surrogate key in his paper RM/T. Wikipedia also has the same definition of the surrogate key. The surrogate key is the primary key of the corresponding binary relations. The surrogate key exists only in thecorresponding database (not in the real world). Codd wrote “now the surrogate that is the primary key and provides truly permanent identification of each entity.� Note that he wrote “provides identification of each entity�, Codd did not write “identifies the entity�. This means that he uses the corresponding primary key fromthe original relation (RM relation) to identify the real world entity (notthe surrogate key, which is primary key of binary relations.) This impliesthat he must maintain the two primary keys. And this implies that he must join the attributes from the primary key and keep them unique. (I hope that I didn't make a mistake in this explanation.) Note that Codd did not maintain the history, he even did not know for “history of events�. So my explanation here is my guessing that “system-assignedsurrogates� must work in this way. Note that Code didn't explain how these things work, he only said, a system does this behind the scene.
==========================

In my paper “Some ideas about a new Data Model�, From September 17, 2005 at http://www.dbdesign10.com/ , see section 1.1, I wrote:
“Besides Ack, every entity has an attribute which is the Identifier of the entity or can provide identification of the entity. This Identifier has one value for all the states of one entity or relationship.�
In this definition I wrote “…or can provide identification of the entity�. This “can provides� means that my solution covers the case of the surrogate key. So the surrogate key is just a special case of my solution. But here the identifier not necessary must be the surrogate. I didn't think specifically about the surrogate key here. I thought on each identifier who can “identify or provide identification�. For example my identifier of a state is 100 times more complex than the surrogate key.

My approach to the identifiers, surrogates and keys is different from Codd's, it is based on the abstract objects and memory manipulation with abstract objects. My approach solves more complex things than the surrogates. (Seethe algorithm in my post from February 25 in this thread. I named that algorithm as “How a database stores an object and how a database can remember of its objects?� )
===========================

The paper “Anchor Modeling An Agile Modeling Technique Using the Sixth Normal Form for Structurally and Temporally Evolving Data� has reference [19].

At [19] the authors of Anchor Modeling wrote that the anchor is the surrogate key. In their paper they also “proved� that all structures from Anchor modeling are in “6nf�. This implies that Anchor Modeling is based on the nothing because I showed in this thread that “6nf� is absurd. This paper was signed by all five authors.Why the authors of “Anchor Modeling� are put the "6nf" in the title? It is because they use these atomic structures in their paper without proof. They use "6nf� and RM/T as implicit proof for their decomposition. As I wrote "6nf" is nonsense.

There are also problems in the Anchor Modeling that are related to transitions from one data model to another data model. It seems to me that the authors of Anchor modeling walk with giant steps through these data models. Firstly they have entities, then they have a set consisting of different typesof attributes.
But nowhere is proven the decomposition of this entity to these attributes.It was not proven that the reverse is true: it is not proven that this attributes forming this entity. What is surprising is that at the beginning ofthis paper the authors write that Anchor Modeling is the Relational Model:"An anchor model is a relational database schema" see section 1.

On August 6, 2010 (see my thread “The original version�) I wrote on this user group the following:
“There is one other thing here, which is more important, which is badly
done in the "Anchor Modeling. This is about how to do the transition
from E / R model in the relational model and vice versa. I think it is
necessary to define the mapping from E / R to RM, then the inverse
mapping for the given mapping and in the end it is necessary to define
the composition mapping. In my model I have at the outset, the binary
concepts. Each binary structure has its own unique identifier of the
state. Therefore, each tuple or a binary concept is uniquely defined.
In "Anchor Modeling" They start from the E / R and go in the RM, so do
6NF, and return to the E / R. But it was not discussed in the paper,
so it's not clear how to do it. We can note that mapping of schemas between
two db models can be complex, for examples it can include constrains.�

Basic terms are not correct or they do not belong to the theory of databases. For example section 2.1 starts with the following text: “An anchor represents a set of entities, such as a set of actors…�
The set of entities does not exist, because we do not put the physical entities into sets. For example, we can say that we have a set whose elements denote actors. Databases work mostly with names, not with physical objects.

Just after the above mentioned sentence, there are the following definitions:
Def1 Let ID be an infinite set of symbols, which are used as identities.

Def2 An anchor A(C) is a table with one column. The domain of C is ID . Theprimary key for A is C.

If somebody wants to check what an identity is, then he can visit web page:Stanford encyclopedia of philosophy, the articles from this web site are written by the prominent scientists. On this web site there is no a definition of Identity, but there are tens of pages about the identity. This is among the most important terms in philosophy. However databases do not work with philosophical terms. I just want to tell you that the most basic term inAnchor Modeling are defined inaccurately.

This paper has the following title: “Anchor Modeling An Agile Modeling Technique Using the Sixth Normal Form for Structurally and Temporally Evolving Data�

I was looking just for the part that is related to “Using the SixthNormal Form for Structurally Evolving Data�. I mean this is reallyimpressive title and notation. However, I could not find anything about "using sixth normal form for structurally evolving data".
If authors of this paper believed they can on "agile" way add attributes tothe existing entities, then they have to realize that they need to swap the existing "identity" of the corresponding entity, i.e. they should change the "anchor".
I have many doubts related to "Agile evolving" especially because there is no explanation or example about it.

This paper was awarded the first prize at the Congress that bears the name "International conference on conceptual modeling," but nowhere in the paper, there is no definition of the concept. Note that the authors introduce unusual concepts, which are about how to keep the identity of the entity thatis changing. Also, we are talking about atomic entities. Therefore definitions of the concepts are important. Note that P. Chen also did not give anydefinition of the concept in his work ERM. ERM is conceptual model.

On the web site of Anchor Modeling the authors write about “meta data�. They have discussion club there, they correct errors and announce the new improved versions. I want to say the following:
1. “meta data� is undefined concept.
2. the authors didn't write in their paper nothing about “meta data�. For example they didn't include “meta data� in schema and they didn’t define which “meta data� areincluded.
3. I am sure that Anchor Modeling can not support “meta data�, but one would be frivolous when criticizing something that is not defined. So nobody who is reasonable person can’t say anything about it..

My point here is that these authors don’t understand what “meta data� is and this imply that they don’t know what the history is. So their solution can not solve the history. In fact these authors think that history is a kind of a temporal database, what is not true at all. Obviously the editors of this paper do not understand the nature of the history.
With these few examples I wanted to draw attention to the low level of thiswork. It also raises the question of how do the editors of this paper did not notice the low level of the paper.
By the way, the reference [19] is disappeared; it is not at the given address.







====================================
(b) CarKey is not a surrogate key by definition. Users can see the value of the surrogate key. If user wants, then he can delete the surrogate, whichhe saw. CarkKey is the identifier of the abstract object i.e. it is the key of the state of an entity. In contrast to Codd’s surrogate key which is related to a real entity, CarKey is related to the abstract object.
CarKey directly identifies the corresponding state, so it is a key, while surrogate keys can’t identify the entities, the surrogate key indirectly identifies the real world entity, and it uses additional database structures.
=====================================

But more important, CarKey is about how to store complex objects in a memory and about how to recall complex objects from a memory (Man can remember of ideas, emotions, music, thoughts, shapes and other very complex objects. Here I mean on a memory for databases. But this can be a clue for general theory about memories. So CarKey goes in that direction. See the algorithm in my post from February 25 in this thread, I named that algorithm as “How a database stores an object and how a database can remember of its objects?�).
The surrogate is about simple objects and the surrogate doesn't work correctly. The surrogate is a naïve technical solution. (the surrogate looksto me as a kind of an index)
Especially Codd’s surrogate doesn't work for General database theory. For example Codd didn't notice very important and huge field in database theory. It is the history. Now, it seems that authors of Anchor Modeling want to “include� Codd’s surrogate in the theory ofthe history of events although Codd didn't notice this very important field.
===================================

Note that each primary key is the identifier. So the corresponding identifier can be physically associated to the corresponding object from the real world. See my paper “Semantic databases and semantic machines�, section 5.1(i) at http://www.dbdesign11.com/ which is about primarykeys.

Keep in mind that a lot of people do not understand what it is a surrogate key. For example, if we have an invoice and if the invoice has an identifier (invoice number), then this is not a surrogate key by definition, becausethe identifier is put on the object in the real world.
I also think that the authors of Anchor Modeling not fully understood the surrogate key. I mean this is obvious.



(c) I posted my solution for the first time on September 23, 2005 on this user group.
Many of the members are understood my paper, and they immediately started the discussion.
It is OK that one can’t understand something; you (or anybody else)can post your questions to the group or can sent it to my email, I will respond.






(d) An entity is a fundamental term here. It is also fundamental semanticunit. The entities are the basic units for relationships.
The surrogate keys are the keys for entities. The anchor is the surrogate key; this is written in reference [19].
In my opinion the surrogate is wrong in Anchor Modeling, because users can see surrogates in Anchor Modeling. It is not a surrogate key by definition..
Therefore the consequence here is the following question: On what is based the decomposition of entities in Anchor Modeling? Is it based on "6nf" or E. Codd's "decomposition" or maybe on some combination of the mentioned approaches?

Vladimir Odrljin

Dana ponedjeljak, 11. velja�e 2013. 08:41:14 UTC+1, korisnik Derek Asirvadem napisao je:

Hi Derek,

1.
In 2005, I solved the binary decomposition for the General databases. Theseare databases that can maintain "history". This decomposition is determined by the applying of the identifier of the state. The drawback of this decomposition is that it can be applied only in the RM, only for General databases.

2.
The binary decomposition of Simple databases, I published on this user group in May 2006th. Then I published "Simple Form". Simple form defines the following:
a) It determines to which relations it can be applied
b) It defines how the relations can be decomposed into binary relations.
Now things have slightly agreed. But the major issue still unresolved. We need the binary decomposition at the level of the conceptual model.

3.
Conceptual model is always the beginning of the construction of the database. But here, in the conceptual model nothing was done, even there was no definition of the concept.
Within the ERM, it was necessary to solve the decomposition of the Simple and the General databases. After that it was necessary to define a mapping from the ERM into RM.
All solutions in the ERM should be done with the tools that belong to the ERM. So we have to work with the concepts.

The "Binary decomposition" at the level of ERM I published in 2008. This paper I had to write in a limited number of pages, because Croatian journal in which I submitted the paper, gives a very small number of pages. That's why this paper has become more difficult to read than usual. I showed this decomposition in Example 6, Section 4.2.3, "Database design and data model founded on concept and knowledge constructs�. In this example, implicitly I used my definition of the concept and the extension of the concept.See also my paper "Semantic databases and semantic machines", section 5 athttp://www.dbdesign11.com Here you can find more on this very complex matter.

In Example 5 is shown working with binary files. I showed only this examplethat relates to the m-n relationships in the file data model, because thisis the hardest part.

4.
In my model, knowledge was associated to the concept. A new definition of knowledge has been given. Knowledge is defined using atomic facts. The difference between the fact and factual sentence is introduced. So a fact is always tied to a subject, that is, the subject knows that fact. This implies the necessity that the subject should be "aware" of the fact.
"Truth conditions" are defined, i.e. the relationship between meaning and truth is introduced.

5.
The mapping (also the corresponding inverse mapping) between ERM and RM is defined. Based on the above mentioned four items, it is obvious that these mappings are defined in the following way:
a) The identifier of the entity defines the mapping for "Simple database";
b) The identifier of the state defines the mapping for “General databases".

6.
First, I define the knowledge, and then I have defined entities that are based on the knowledge. In my model, the construction of the entity does not use undefined terms such as the "metadata".

7.
My model allows you to work on all aspects related to the history of events.. This is a special large area and therefore I will not explain it here. History is one of the greatest contributions that my solution adopted. This drastically changes the theory of database.

8.
In the item 8 I will discuss the thing that has been in the forefront in this thread. It is the story about the surrogates. The story has boosted the importance of the surrogates to a size with which, the real surrogates havenothing to do.
I'll try here to show two things that are an important part of the "big picture" and that they represent some "general" conditions.

One thing is important here, it's my algorithm that is related to memory management. It is an algorithm that defines how to store an entity in the memory and how recall it from memory, and for which kinds of the objects it works. I wrote about this algorithm, in more details in my post from February25, 2013, in this thread.
If we talk in generalized terms, it can be said that this algorithm is about procedures for memory and remembrance (recollect).

Another thing is about some “general� conditions:

(a)
The main part of solving “temporal�, “historical� and other complex databases consists of two sub-steps:
1. Constructing an identifier of an entity or relationship.
2. Connecting all changes of states of one entity (or relationship) to the identifier of this entity (or relationship).

I had published this idea on my website http://www.dbdesign10.com and
in this user group in 2005 (see section 1. and 2.)

(b)
“We determine the Conceptual Model so that every entity and every relationship has only one attribute, all of whose values are distinct. So this attribute doesn’t have two of the same values. We will call thisattribute the Identifier of the state of an entity or relationship. We will denote this attribute by the symbol Ack. All other attributes can have values which are the same for some different members of an entity set or a relationship set. Besides Ack, every entity has an attribute which is the Identifier of the entity or can provide identification of the entity. This Identifier has one value for all the states of one entity or relationship.� (See section 1.1)
--
Here are given the general conditions for the construction of procedures that are necessary to maintenance the history of events and their applicationto the identifiers and keys. I would like to emphasize once more: The general conditions are the mentioned procedures, not an “immutable key�. I mean, AM was only took “immutable key� from myprocedures. I wrote “the general conditions� because thereare many specific conditions in the construction of General database theory. I would like to mention that the next part of the definition: "... or can provide identification of the entity" from case (b), does not apply so much to the surrogates, as they apply to other cases. These cases are more general than surrogates. As I wrote, the surrogate key is unimportant case.

I also want to show that Codd’s thinking about these issues was kind of narrowly oriented and technical solutions. I mean that he did not understand the nature of these matters. The authors of Anchor Modeling, were applied the surrogate key in the same manner of misunderstanding of the difference between technical solution and theoretical solution and the difference between a special case and the general case.

The authors of AM gave the name of "immutable" to certain keys. Recently, Iquickly glanced what Microsoft is doing with their "EDM", and there I noticed that they used the term "immutable type."
In my model, I gave two options for the identifier of the entity, it may beimmutable or it may be mutable, depending on db design. So immutability depends on db designer. For example, it is known that in the U.S. a man in particular situations can change his identity. In the real use of databases, there is the need when an identifier should be immutable only at one period, for example, the identifier must be changed each year, so the identifier is immutable in one year and after that, this identifier must be changed.
In my paper "Database design and data model founded on knowledge constructs", section 4.2.4, I wrote: "In the states of an entity, the identifier of the entity stays unchanged through all the states of the entity, because thestates are from one entity (however if we want, then we can decide and determine which of the states belong to one entity). The identifier of the entity determines which states belong to the entity. If an entity only has onestate, then the identifier of the entity is semantically equal to the identifier of the state.�
In my paper “Semantic databases and semantic machines�, section 5.12, I demonstrated that history of entities, which changes its identifiers, can be maintain by “seq� structure.
Note that unary relations from RM/T are simple special case of the structure “seq�. The Anchors also are very simple special case of the structure “seq�.
However RM/T and AM can not solve some important matters that the structure“seq� can solve.

--------------------------------------------
Conclusion:

None of the above mentioned eight items E. Codd did not do. These items arevery important. Item 7, it is history, changed a lot in the db theory. I think Codd did not even notice these areas. The same can be said for AM. Note that I published solution for history, 4 years before it did Anchor Modelling.
Therefore we might set the following question: Does the decomposition presented in "RM / T" is correct? The same question can be asked for AM. Does this decomposition of the structures that are shown in the AM is correct?

I mean, there are no proofs for these decomposition. These are the most important things, and many scientists were tried to prove it. As you can see Codd and AM are the exceptions, they have been able to publish their solution without proof.

From the papers, it is obvious that these decomposition are done, without any proof. How is it possible that such well-known journals have so scandalous omission? AM uses Codd's surrogates. Note that the paper about "AM" has the following title: "An Agile Modeling Technique using the Sixth Normal Form for structurally and Temporally envolving Data", despite the fact that 6nf is unusable.

As I wrote in this thread the surrogate key is not the main thing here. Themain thing here is the decomposition into the binary (atomic) structures. This is crucial not only for database theory but also in some other areas.

Vladimir Odrljin

Hi Derek,



I appreciate your comments. On this occasion I would like to quote the following: “During times of universal deceit, telling the truth becomes a revolutionary act.”
--George Orwell

I think that behind each act, there is concrete man, with his name. Therefore in this thread, I concentrate on facts and names.

1. My paper completely solves the area from database theory, which I call the "history of events". This area is actually a general approach to the theory and practice of database. This general approach to databases, I called general theory of databases or abbreviated "General databases". In my post on February 13, 2013, I wrote with which areas are dealing General databases.

2.
I had published my ideas on my website http://www.dbdesign10.com and in this user group in September 2005. Here is a link to the comp.databases.theoryuser group, where I presented my ideas in 2005:
http://groups.google.com/group/comp....f846beb00cc56# (there are also many other links where the ideas were clearly presented)

Anchor Modeling was published in November 2009 and fixed version was published in October 2010. Everybody can see these facts on the internet. The internet is the global auditorium. I mean I have global witnesses.

3.
On 12 April, 2013, in this thread I wrote about some general conditions which must be satisfied. It is about identification, simple key and algorithm about storing and recalling different kinds of objects into a memory. So the following ProcedureA gives general conditions:
===============================
ProcedureA
(a)
The main part of solving “historical” and General databases consists oftwo sub-steps:
1. Constructing an identifier of an entity or relationship.
2. Connecting all changes of states of one entity (or relationship) to the identifier of this entity (or relationship).

I had published this idea on my website http://www.dbdesign10.com and in this user group in 2005 (see section 1. and 2.)

(b)
“We determine the Conceptual Model so that every entity and every relationship has only one attribute, all of whose values are distinct. So this attribute doesn’t have two of the same values. We will call this attribute the Identifier of the state of an entity or relationship. We will denote this attribute by the symbol Ack. All other attributes can have values which are the same for some different members of an entity set or a relationship set. Besides Ack, every entity has an attribute which is the Identifier of the entity or can provide identification of the entity. This Identifier has one value for all the states of one entity or relationship.” (See section 1.1)
===============================
Anchor modeling uses the schema which is given in part (a); it uses both ofthe following sub-steps:
1. Constructing an identifier of an entity.(This is about the construction of the simple key)
2. Connecting all changes of one entity to the identifier of this entity.

This is plagiarism.

The identifier is a more general solution than a surrogate key. The idea ofthe identifier allows presenting key as simple key instead of a complex key.

ProcedureA is important also for others fields, for example for philosophy,logic and semantics. People have always held that a name denotes a certainentity, although this entity has been changed many times. But the following problem has always existed: How an entity which has changed to another entity is, in fact, the same entity. This problem is solved in my paper. An anchor surrogate key and a surrogate key without ProcedureA does not help atall.
In my paper I gave the corresponding procedures, constructions and semantics for solving this problem. Note that I introduced concepts that are related to these fields and procedures.

ProcedureA was caused a lot of problems. On conceptual level the decomposition of the data structures has not been solved.
How to explain the binary concept, which consists of the identifier of the entity and one attribute? I have introduced the intrinsic, extrinsic and universal attribute. This has led to the expansion of Leibniz Law of identity.. I am writing this, because I want to show a complexity of the problems that solves ProcedureA.

ProcedureA has a general character. It solves the following:

i) The surrogate key. (See sentence “ Besides Ack, every entity has an attribute which is the Identifier of the entity or can provide identificationof the entity.”, in ProcedureA, case (b))
To be precise, this is not 100% the same as a surrogate key. The surrogate key is the technical solution, it is index, it is not a theory. The mentioned part of my definition of the key is more general then the surrogate key.
What's the difference between this part of my definition and the surrogate key?
My key is always "visible" and it always uses ProcedureA which determines the
general conditions.
Another important difference between my identifiers and surrogates is that my
identifier always belongs to an object. It belongs to a real entity or to an abstract object or it belongs to both the real and the abstract object.
(ii) ProcedureA enables work with abstract objects. My main structure is the state of the entity or relationship. The key of this structure is the identifier of the state of the entity or relationship. ProcedureA is the basic procedure for the construction of History.
As I have already said, the state of an entity was defined as the totally knowledge about the entity (or relationship). Total knowledge means that knowledge from more than one man, is also included in total knowledge. It possible that one man says that the color of the car is blue and another man claims that the color of the car is dark-green. In this case, my solution canmaintain History.

The identifier of a state of an entity can identify the entity. A surrogatekey can also identify an entity. However, the identifier of a state of an entity is not the key of the entity. An entity and the state of the entity are two very different things.
I wrote in more details about the algorithm that is related to memory management, in my post from February 25, 2013, at this thread. My state structure has both of identifiers, the identifier of the entity and the identifier of the state of the entity. The state is not fully abstract object, it is the state of the real entity. So the state is a combination of the real object and the abstract object. This situation is resolved by using "Combination" of appropriate identifiers. In fact this "combination" enables
storing and recalling of complex objects into / from memory.

So this is the rule; the combination of identifiers solves the "Store" and "Recall" of complex objects into / from memory.

I also wrote about relationship between concept and identification, see thesemantic procedure (3.3.3) in my paper “Database design and data model founded on knowledge constructs".

This semantic procedure shows that so-called Russell's paradox is not correct (see my thread “ Does the phrase “Russell’s paradox” should be replaced with another phrase?" posted on this user group ). More important it shows that identification is another mind - real world link and that attributes are identifiers.
As I wrote above, the identifier in my model is an attribute. (it belongs to a real or abstract object). So the identifier from my ProcedureA is part of complex construction (procedure). It is not matter of system because it also has semantic nature (it is mind – real link world).
In contrast to my solution, a solution that uses the surrogate key has no semantic nature, even more, the surrogate key is invisible to users.
(iii) There are mathematical theories that are partially dealing with history. It is for example Modal Logic, which deals with "Possible World". There is a The situation theory, etc. However, these theories have very generalnature and do use the undefined terms such as "World".
I have already mentioned that Microsoft in its EDM model introduces history..
Another theory called Abstract State Machines now also introduces History.
(See http://www.w3.org/TR/scxml/ look for History).
It is also clear that we now need adequate mathematical theory for "Historyof
events".

I write about this here, so that one can understand the scale and importance of this plagiarism.

Note that in working with the History, the surrogate key is not important. ProcedureA is essential.

4. Anchor Modeling uses other essential elements from my work. If someone link these elements together, then he can get a strong theory of history. These are the following elements:
(i) Decomposition into the atomic structure

The decomposition into atomic structures in Anchor Modeling was done at the
conceptual level without a proof. They just put some “atomic structures” into their paper.
Anchor Modeling does a transition of these “Atomic structures” from Conceptual model into RM without a proof or explanation. The same “technique” was applied in RM/T.

Then they proved that the corresponding relvars are in 6nf. The subtitle ofthis paper is as follow: “An Agile Modeling Technique using the Sixth Normal Form for Structurally and Temporally Evolving Data”. The sixth normal form is just a list of desires about the decomposition into atomic structures. It does not provide a solution, procedure or algorithm that allows the decomposition of a relvar into 6nf. I explained that 6nf does not work properly in the following example: if we have a relvar with mutually independent attributes then 6nf has no sense.

I want to say clearly that a lot of people spent their time trying to get the atomic structures. A lot of people also try to construct mapping betweendata models. In RM/T and AM this was done without proof and published as scientific paper.
One important step in the construction of atomic structures and mapping between
data models is History.

In the paper Anchor Modeling in reference [19], all five authors claim thatthey use the surrogate key. ("H (C, D, T) contains, as seen above an anchor surrogate key”, see page 2). Even more they use the surrogate key in SQL!

By definition the surrogate key is not visible and never displayed. Everybody can see the definition of the surrogate key in RM / T, or Wikipedia, etc.. In my opinion this is very serious. The Springer and Data & Knowledge Engineering are well known referential journals used by many scientists. Thesejournals must not allow the use of erroneous construction. Especially as E.. Codd used surrogate for decomposition into binary structures, which is not proven in the RM / T. Now, we can set the question: On which the Anchor Modeling was founded? Obviously Anchor Modeling is based on nothing.

Note that the author of Anchor Modeling first used the term "surrogate key", and
then "identities" and finally "identifier", which are very different things.. It is obvious that these fundamental concepts are not clear to the authors of Anchor Modeling and to editors of the paper.

However if you think that I am wrong here then let me know.

This paper, in which all five authors claimed that Anchor's values are the surogate keys, was disappeared from the list of references. I started to write about reference [19] (see my thread "The original version "). The authors of Authors Modeling, returned the paper to the list of references, but in their other paper.

Please note that the decomposition into the binary structures is proved in my papers.

(ii) In my model, I took that entities have different sets of data. These are: the knowledge about the entity, knowledge about the attributes and knowledge about the data. In my model, it is possible implement various additional knowledge.
Anchor Modeling also uses different sets of data, but fixed and limited setof data.
Note that my data model is more general than Anchor Modeling and that is not based on undefined terms, such as "metadata".
Note that Anchor Modeling did not present work with "metadata" at all. In fact
Anchor Modeling can resolve only a very simple "metadata". You can take my
example 2.5, from my website http://www.dbdesign10.com and you can notice that
there is no structure from Anchor Modeling which can solve History for this
example.

(iii) Date when some information is created and the date when this information ceased to exist.
Anchor Modeling uses also two dates. The authors of Anchor Modeling pay attention to “bitemporal” data. In fact they didn’t notice that my modelenables n-temporal data.
For example for one attribute you can have four StratDate: StartDate1 when an
attribute get value in the real world; StartDate2 when the value for the attribute was entered in database; StartDate3 when the value of the attribute was entered in Warehouse; StartDate4 when the attribute was transferred to xml. Note that I do not use Data warehouse because I have only database, but Anchor
Modeling uses Data warehouse, they have the section which is devoted to Data
warehouse. I mean in theory it should be n-temporal data instead bitemporal..

Note that in Anchor Modeling the temporal data and “metadata” are outside the
scope of predicate logic, what is a kind of a disaster for RM. In contrast to Anchor Modeling my model enables the formalization of tensed propositions.

Vladimir Odrljin