CN104699761B - A kind of incremental calculation method of minimal functional dependencies - Google Patents

Abstract

The invention discloses an incremental calculation method of minimum function dependence. According to the minimum non-trivial function dependency set before the change of the relationship table, the incremental data set, and the division information set of the relationship table before the change, the method incrementally detects the original Whether the minimum functional dependency of is established, and finally determine the minimum non-trivial functional dependency set after the relationship table changes. According to the operation type (addition, deletion or modification) of the tuple, the method performs the incremental calculation of the corresponding minimum functional dependency. Since in practical application, after the database changes, most of the minimum functional dependencies in the original data set are valid, the method proposed by the present invention does not need to recalculate all the minimum functional dependencies of the new data set, and only needs to calculate the original minimum functional dependency set The minimal functional dependence of adding and deleting, so the efficiency is high, the flexibility is strong, and the calculation results are accurate.

Description

A Method of Incremental Computing with Minimal Functional Dependency

technical field

The invention relates to the field of computer data processing, in particular to an incremental calculation method with minimum function dependence.

Background technique

With the rapid advancement of informatization in all walks of life, the emergence of massive and dynamic databases has made data analysis and processing face severe challenges. The database is changing, and the knowledge reflected by the data is also changing. How to efficiently and dynamically maintain the knowledge obtained from data mining is an important topic in the database field. In recent years, database integrity constraints are being widely used in data analysis and processing, as well as detecting inconsistent data and improving data quality.

At present, most of the information systems and data centers of government departments, enterprises and other units use relational database management as the core. In order to quickly and accurately identify abnormal data such as errors and inconsistencies, efficient and feasible technical and method support are needed. Data quality inspection Tools are in increasing demand. From the perspective of usage, the data quality detection method is suitable for: business data processing and statistics, data archiving, data warehouse maintenance, data cleaning, data integration or integration. For this reason, it will become an inevitable trend to introduce data quality management platforms and establish data quality inspection systems at all levels in the informatization construction process of governments, institutions, and enterprises in the next few years. Abnormal data detection methods such as errors and inconsistencies and corresponding detection tools have good industrial prospects.

Functional Dependency (FD for short) is one of the important constraints of relational databases, not only the basis of database design, but also the basis of data quality monitoring and control. Although functional dependencies can be defined as data constraints in the database management system, in many cases, when the database is constructed, the functional dependencies are not clearly defined, or cannot be clearly formulated when the database is constructed, and it is necessary to mine or calculate the functional dependencies through data sets, and As the database changes, they need to be maintained to ensure the accuracy of detecting abnormal data.

Algorithms for computing functional dependency sets have been studied for many years, and the two most representative algorithms are hierarchical algorithms (for example, "TANE: An efficient algorithm for discovering functional and approximate" published by Y. Huhtala, J. Karkkainen, etc. in 1999 dependencies") and depth-first algorithms (such as "FastFDs: A heuristic-driven, depth-first algorithm for mining functional dependencies from relationinstances-extended for abstract" published by C.M.Wyss, C.Giannella, E.L.Robertson, etc. in 2001), As the database changes, the functional dependencies may also change, that is, the original functional dependencies are no longer established, and new functional dependencies are generated. At present, there are two main ways to calculate the functional dependence and the minimum functional dependence after the database change:

(1) Recalculation: For the changed database, recalculate the functional dependence according to a certain functional dependence calculation method, without using the changed part of the data set (that is, the added tuple, the deleted tuple, the modified tuple), the original calculation The minimum functional dependency set and partition information obtained.

(2) Incremental calculation: mainly based on the changing part of the data set, the original minimum functional dependency set and partition information, incrementally detect whether the original minimum functional dependency is established, and calculate the newly added minimum functional dependency.

At present, for dynamically changing databases, the algorithms for calculating functional dependency sets and minimum functional dependencies are recalculated, such as TANE algorithm, FastFDs algorithm and improved algorithms based on them. For the changed database, the method of recalculating the minimum functional dependency is used to repeatedly calculate the same minimum functional dependency as the database before the change. As the database grows, the time efficiency is low. In practical applications, as the database changes, most of the minimum functional dependencies remain unchanged or hold, so recalculation is unnecessary.

Therefore, it is of great application value to propose a method with high computational efficiency, strong flexibility, and incremental calculation to calculate the minimum functional dependence.

Contents of the invention

The purpose of the present invention is to overcome the shortcomings and deficiencies of the prior art, and provide a method for incremental calculation of minimum functional dependence. The method adopts an incremental calculation method to calculate minimum functional dependence from changing relational data sets, and has high calculation efficiency. , and the calculation result is accurate.

In order to overcome the deficiencies of the existing methods and technologies, the present invention incrementally detects whether the original minimum functional dependence is established according to the change data set, the minimum functional dependence set and the division information before the relational table change, and calculates the newly added minimum functional dependence .

The mathematical definitions involved in the technical solution of the present invention are first listed as follows:

Definition of functional dependencies: Let R be a relational schema, Y∈R, the condition for the establishment of functional dependence X→Y is: for a relational table r with schema R and any two tuples t ₁ and t ₂ in r, and all B∈X, if t ₁ [B]=t ₂ [B], then t ₁ [Y] = t ₂ [Y]. If Y∈X, X→Y is trivial.

Definition of minimal functional dependency: Let R be a relational schema, Y∈R, the functional dependence X→Y holds, if for any non-empty Z→Y is not established, then X→Y is the minimum functional dependence.

The present invention only studies the incremental calculation method of minimum non-trivial function dependence. The functional dependencies mentioned below all refer to non-trivial functional dependencies, and the minimum functional dependencies refer to minimum non-trivial functional dependencies.

Definition of equivalence class: A certain equivalence class [t] _X of an attribute set X means that in a given relational table, all the values corresponding to tuple t on X are equal (referred to as equal to t on X) ) set of tuples.

Definition of division: The division on attribute set X is the set of all equivalence classes of X in a given relational table r, denoted as π _X , where |π _X | represents the number of equivalence classes in π _X.

The method of judging whether the function depends on X→Y is true: if |π _X |=|π _X∪{Y} |, then the function depends on X→Y; otherwise, it does not hold. According to this method, the present invention judges whether the functional dependence is established.

The method of judging whether the functional dependence X→Y is the minimum functional dependence: the functional dependence X→Y is established, and if for any If Z→Y is not established, then X→Y is the minimum functional dependence; otherwise, it is not the minimum functional dependence. According to this method, the present invention determines whether the functional dependence is the minimum functional dependence.

Assuming that the given relational schema is a relational table r of R, the following identifiers are specified:

△r: Capture the changing set of incremental tuples in a given cycle;

|R|: the number of attributes included in R;

r _new : the new relationship table after the change;

Partitions: the partition information set before the relational table r changes;

Partitions_new: r _new partition information set;

FDs_old(r): the minimum non-trivial functional dependency set before the relational table r changes;

FDs_new(r _new ): The minimum non-trivial functional dependency set after the relational table r changes.

On the basis of the above-mentioned mathematical definition, the specific technical solution of an incremental calculation method with minimum functional dependence in the present invention will be described in detail below.

The present invention is an incremental calculation method of minimum functional dependence. The minimum non-trivial functional dependency set, the incremental tuple set, and the division information set of the relational table before the change are known, and firstly, according to the incremental tuple concentration The operation type and attribute value of all tuples, modify the partition information in the partition information set, and then incrementally check whether each original minimum non-trivial function dependency is still the minimum non-trivial function dependency in the changed relational table, if yes , it will be kept in the minimum non-trivial functional dependency set; if not, it will be deleted from the minimum non-trivial functional dependency set, and the new minimum non-trivial functional dependency after the change of the relationship table will be calculated.

Specific steps are as follows:

(1) Select the initial relational table r whose relational mode is R to operate, record the incremental tuple into △r, and obtain the changed new relational table r _new ;

(2) Modify the division information in Partitions according to the operation types and attribute values of all tuples in the incremental tuple set △r;

(3) Initially, let FDs_new(r _new )=FDs_old(r);

(4) Read a tuple t _p from △r;

(5) According to the operation type of the tuple t _p , the incremental calculation of the minimum functional dependence is performed as follows:

(5-1) If t _p is an added tuple, the steps to modify FDs_new(r _new ) are as follows:

(5-1-1) Read a minimum function dependency f in FDs_new(r _new ), let f: X→Y;

(5-1-2) Determine whether the functional dependence f is established in r _new , if it is established, f is still the minimum functional dependence, retained in FDs_new(r _new ), and go to step (5-1-4); if not established , delete f in FDs_new(r _new ), go to step (5-1-3);

(5-1-3) For (5-1-2) judged to be no longer valid functional dependence: X→Y, determine whether X∪Z→Y not in FDs_new(r _new ) is the minimum function in r _new Dependency, if so, then X∪Z→Y is the newly added minimum functional dependency, which is added to FDs_new(r _new ), where: "-" is the difference operator of the set, and Z is not empty;

(5-1-4) Determine whether there are unread minimum functional dependencies in FDs_new(r _new ), if so, repeat steps (5-1-1)~(5-1-3); if not, then Go to step (6);

(5-2) If t _p is a deleted tuple, the steps to modify FDs_new(r _new ) are as follows:

(5-2-1) Read a minimum function dependency f in FDs_new(r _new ), let f: X→Y,

(5-2-2) If |X|=1, f is still the minimum functional dependency in r _new ;

If |X|＞1, for all And Z is not empty, judge whether Z→Y is the minimum functional dependency in r _new , if so, add it to FDs_new(r _new ), and delete f in FDs_new(r _new );

If there is no Z→Y minimum functional dependency in r _new , then determine whether f is still a functional dependency in r _new , if so, then f is still a minimum functional dependency in r _new ; if not, then in FDs_new(r _new ) to delete f;

(5-2-3) Read an attribute A from R, and use the following steps to calculate other newly added minimum functional dependencies:

(5-2-3-1) set And X is not empty}, X is a non-empty attribute set that does not contain A, L=1;

(5-2-3-2) If C is not empty, then Otherwise, go to (5-2-4);

(5-2-3-3) If C' is not empty, for each element X in C', for X→A not in FDs_new(r _new ), determine whether it is the minimum functional dependency, and if so, set X→A is added to FDs_new(r _new ), and all X∪Y elements are deleted in C, where and

(5-2-3-4) Add 1 to L;

(5-2-3-5) If C is not empty, and L<|R|-1, then repeat steps (5-2-3-2)~(5-2-3-4); otherwise, go to step (5-2-4);

(5-2-4) Determine whether there are attributes that have not been read in R, if so, repeat step (5-2-3); if not, enter step (5-2-5);

(5-2-5) Determine whether there are unread minimum functional dependencies in FDs_new(r _new ), if so, repeat steps (5-2-1)~(5-2-4); if not, then Go to step (6);

(5-3) If t _p is a modified tuple, for each modified attribute A in t _p , let t _p be expressed as: (v ₁ ,...,(v _A -old,v _A -new), …,v _n ), the steps to calculate FDs_new(r _new ) are as follows:

(5-3-1) If Z=X∪Y}, take (v ₁ ,...,v _A -old,...,v _n ) as a deletion tuple, and modify FDs_new(r _new ) according to step (5-2);

(5-3-2) If A∈{Z|X→Y∈FDs_new(r _new ), Z=X∪Y}, first take (v ₁ ,…,v _A -old,…,v _n ) as To delete a tuple, modify FDs_new(r _new ) according to step (5-2); then treat (v ₁ ,…,v _A -new,…,v _n ) as an added tuple, follow step (5-1) Modify FDs_new(r _new );

(6) Determine whether there are unread tuples in △r, if so, repeat steps (4) to (5); if not, go to step (7);

(7) Save the partition information set Partitions_new of FDs_new (r _new ) and r _new ;

(8) Output FDs_new(r _new ).

The minimum functional dependency set and partition information of the initial relational table r are obtained by using the existing minimum functional dependency calculation algorithm TANE. The invention proposes a method for incrementally calculating a new minimum functional dependency set after a relational table is changed.

Compared with the prior art, the present invention has the following advantages and beneficial effects:

(1) The inventive method has higher efficiency. Incremental calculation is adopted to modify the partition information for different types of tuple operations without rescanning the database, and in most cases, the incremental data, the original minimum functional dependency set and partition information are used to calculate the new Or the minimal functional dependencies removed also don't require rescanning the database.

(2) The method of the present invention avoids repeated calculation of the minimum functional dependencies that are still valid in the modified data set. In practical applications, after the database changes, most of the minimum functional dependencies in the original data set are valid. The method proposed by the present invention does not need to recalculate all the minimum functional dependencies of the new data set, and only needs to calculate the original minimum functional dependencies. Minimal functional dependencies for adding and removing.

(3) The calculation result of the present invention is correct and flexible. At present, there are some methods for approximately calculating the minimum functional dependence, which cannot guarantee the correctness of the minimum functional dependence, but the results of the incremental calculation of the present invention are consistent with the results of the non-incremental calculation, and when the data set changes, the minimum functional dependence set can be Modify at any time, that is, modify in time according to needs and cycles.

Description of drawings

Figure 1 is a flow chart of the method of the present invention.

detailed description

The present invention will be further described in detail below in conjunction with the embodiments and the accompanying drawings, but the embodiments of the present invention are not limited thereto.

Example 1

Referring to FIG. 1 , this embodiment takes a data set whose relation mode is R as an example to illustrate the implementation of the present invention.

(1) Relational mode R={StuID, Name, City, Province}, Table 1 is a relational table r of R mode, including five tuples (each row is a tuple); Table 2 is its incremental operation Table △r, wherein: OP column represents the type of incremental operation on r, Del represents deletion, Ins represents increase, Up represents modification, and the modified tuple attribute item includes old value and new value, and its form is: 'old value, new value'. Table 3 is the relational table r _new modified by the operations in Table 2. Note: Different symbols in the above three tables represent different attribute values, and the leftmost number represents the unique number of a given tuple.

The minimum functional dependency set FDs_old(r) of relational table r is as follows:

FDs_old(r)={{Name, City}→StuID,

{Name, Province}→StuID,

{StuID}→Name,

{StuID}→City,

{Name, Province}→City,

{StuID}→Province,

{City}→Province}

The partial division information of the relational table r is as follows, where the numbers represent the unique numbers of the tuples:

π _{StuID} = {{1},{2},{3},{4},{5}}

π _{Name} = {{1},{2},{3},{4,5}}

π _{City} = {{1},{2,3},{4},{5}}

π _{Province} = {{1,2,3},{4},{5}}

π _{StuID,Name} = {{1},{2},{3},{4},{5}}

π _{{City,Province}} = {{1},{2,3},{4},{5}}

π _{{Name,Province}} = {{1},{2},{3},{4},{5}}

π _{{Name,Province,City}} = {{1},{2},{3},{4},{5}}

Table 1 relational table r

Table 2 Incremental operation table △r

Table 3 The modified relationship table r _new

StuID name City Province e ₀ n ₀ SZ GD e ₂ n ₂ GZ GD e ₃ n ₃ CS HN e ₄ n ₄ WH HB e ₅ n ₅ GZ GX

(2) Read all tuple operation types and attribute values in Δr in turn, and modify the partition information in Partitions:

Read the operation tuple t ₂ with the number 2. Since it is a delete operation, part of the division information changes as follows:

π _{StuID} = {{1},{3},{4},{5}}

π _{Name} = {{1},{3},{4,5}}

π _{City} = {{1},{3},{4},{5}}

π _{Province} = {{1,3},{4},{5}}

π _{StuID,Name} = {{1},{3},{4},{5}}

π _{{City,Province}} = {{1},{3},{4},{5}}

π _{{Name,Province}} = {{1},{3},{4},{5}}

π _{{Name,Province,City}} = {{1},{3},{4},{5}}

Read the operation tuple t ₆ numbered 6. Since it is an insert operation, part of the division information changes as follows:

π _{StuID} = {{1},{3},{4},{5},{6}}

π _{Name} = {{1},{3},{4,5},{6}}

π _{City} = {{1},{3,6},{4},{5}}

π _{Province} = {{1,3},{4},{5},{6}}

π _{StuID,Name} = {{1},{3},{4},{5},{6}}

π _{{City,Province}} = {{1},{3},{4},{5},{6}}

π _{{Name,Province}} = {{1},{3},{4},{5},{6}}

π _{{Name,Province,City}} = {{1},{3},{4},{5},{6}}

Read the operation tuple t ₅ with the number 5. Since it is a modification operation, part of the division information changes as follows:

π _{StuID} = {{1},{3},{4},{5},{6}}

π _{Name} = {{1},{3},{4},{5},{6}}

π _{City} = {{1},{3,6},{4},{5}}

π _{Province} = {{1,3},{4},{5},{6}}

π _{StuID,Name} = {{1},{3},{4},{5},{6}}

π _{{City,Province}} = {{1},{3},{4},{5},{6}}

π _{{Name,Province}} = {{1},{3},{4},{5},{6}}

π _{{Name,Province,City}} = {{1},{3},{4},{5},{6}}

(3) Make FDs_new(r _new )=FDs_old(r), so as to get:

FDs_new(r _new )＝{{Name，City}→StuID,

{Name, Province}→StuID,

{StuID}→Name,

{StuID}→City,

{Name, Province}→City,

{StuID}→Province,

{City}→Province}

(4) Read the operation tuple t ₂ with the number 2 from △r, the operation type is delete, and perform the incremental calculation of the minimum functional dependency as follows:

For the functional dependencies in FDs_new(r _new ): {StuID}→Name,{StuID}→City,{StuID}→Province,{City}→Province, since |{StuID}|=1, |{City}|= 1, so they are still minimally functionally dependent.

For the functional dependency in FDs_new(r _new ): {Name, City}→StuID,|{Name, City}|>1, Since |π _{Name} |=|π _{StuID,Name} |, it can be judged that: {Name}→StuID is established in r _new , and it is the minimum functional dependency. Therefore, add it to FDs_new(r _new ), And delete {Name, City}→StuID in FDs_new(r _new ), and it can be judged that {City}→StuID is not established.

For the functional dependency in FDs_new(r _new ): {Name, Province}→StuID, |{Name, Province}|>1, since {Name}→StuID has been established, it is no longer the minimum functional dependency, and it is changed from FDs_new(r _new ), and it can be judged that {Province}→StuID is not established.

For functional dependencies in FDs_new(r _new ): {Name, Province}→City, |{Name, Province}|>1, Since |π _{Name} |=|π _{Name,City} |, it can be judged that: {Name}→City is established in r _new , and it is the minimum functional dependency. Therefore, add it to FDs_new(r _new ), And delete {Name, Province}→City in FDs_new(r _new ), and it can be judged that {Province}→City is not established.

at this time:

FDs_new(r _new )＝{{Name}→StuID,

{StuID}→Name,

{StuID}→City,

{Name}→City,

{StuID}→Province,

{City}→Province}

Next, calculate other newly added minimum functional dependencies: Read each attribute in turn from R, for example: read the attribute Province, and use the following steps to calculate other newly added minimum functional dependencies:

i) L=1;

ii)

ⅲ) For each element X in C′, determine whether X→Province is the minimum functional dependency. It can be judged that {Name}→Province that is not in FDs_new(r _new ) is the minimum functional dependency, and add it to FDs_new(r _new ), and delete {Name} in C, C is empty.

In addition, by reading the StuID and Name properties sequentially from R, you can also determine the new minimum functional dependency: {City, Province}→StuID, {City, Province}→Name.

at this time:

FDs_new(r _new )＝{{Name}→StuID,

{StuID}→Name,

{StuID}→City,

{Name}→City,

{StuID}→Province,

{City}→Province,

{Name}→Province,

{City，Province}→StuID,

{City, Province}→Name}

(5) Read the operation tuple t ₆ with the number 6 from △r, the operation type is insertion, that is, increase, and perform the incremental calculation of the minimum functional dependence according to the following method:

For each minimum functional dependency in FDs_new(r _new ), determine whether it is established as a functional dependency in r _new , and if it is true, f is still the minimum functional dependency and is retained in FDs_new(r _new ). According to the modified division information, |π _{City} |≠|π _{{City,Province}} |, so {City}→Province is no longer established, and it is deleted from FDs_new(r _new ); others are in FDs_new(r _new ) in the minimal functional dependencies are still valid.

For the functional dependency that no longer holds true: {City}→Province, determine whether {City}∪Z→Y that is not in FDs_new(r _new ) is the minimum functional dependency in r _new , where, And Z is not empty, that is, Z={StuID, Name}. Thus, the newly added minimal functional dependencies are obtained: {StuID, City}→Province, {Name, City}→Province.

at this time:

FDs_new(r _new )＝{{Name}→StuID,

{StuID}→Name,

{StuID}→City,

{Name}→City,

{StuID}→Province,

{StuID，City}→Province,

{Name, City}→Province,

{Name}→Province,

{City，Province}→StuID,

{City, Province}→Name}

(6) Read the operation tuple t ₅ with the number 5 from △r, the operation type is modification, and perform the incremental calculation of the minimum functional dependency as follows:

The modification operation is decomposed into: delete tuple (e ₄ , n ₃ , WH, HB), insert tuple (e ₄ , n ₄ , WH, HB), follow the method of deleting tuple and inserting tuple in turn Incremental computation of minimum functional dependencies, where FDs_new(r _new ) is unchanged after processing.

(7) All the tuples in △r have been processed, and FDs_new(r _new ) and the partition information set Partitions_new of r _new are saved as the original minimum functional dependency set and partition information for the next incremental calculation.

(8) Output FDs_new (r _new )

The above-mentioned embodiment is a preferred embodiment of the present invention, but the embodiment of the present invention is not limited by the above-mentioned embodiment, and any other changes, modifications, substitutions, combinations, Simplifications should be equivalent replacement methods, and all are included in the protection scope of the present invention.

Claims (2)

1. a kind of incremental calculation method of minimal functional dependencies, it is characterised in that including step：

(1) choice relation pattern is that R initial relation table r is operated, and increment tuple be recorded in △ r, after obtaining change New relation table r_new；

(2) according to all tuple action types and property value in increment tuple set △ r, the division letter of the relation table before modification change Division information in breath collection Partitions；

(3) when initial, the minimum non-trivial fun collection FDs_new (r after relation table change are made_new) it is equal to relation table change Preceding minimum non-trivial fun collection FDs_old (r)；

(4) a tuple t is read from △ r_p；

(5) according to tuple t_pAction type, carry out the incremental computations of minimal functional dependencies, method is as follows：

(5-1) is if t_pIt is increased tuple, modification FDs_new (r_new) the step of it is as follows：

(5-1-1) reads FDs_new (r_new) in a minimal functional dependencies f, if f：X→Y；

(5-1-2) decision function relies on f in r_newIn whether set up, if so, f is still minimal functional dependencies, is retained in FDs_ new(r_new) in, and go to step (5-1-4)；If not, in FDs_new (r_new) in delete f, go to step (5-1-3)；

The functional dependence that (5-1-3) is judged to no longer setting up for (5-1-2)：X → Y, judge not in FDs_new (r_new) in X ∪ Z → Y are in r_newIn whether be minimal functional dependencies, if so, then X ∪ Z → Y are newly-increased minimal functional dependencies, add FDs_ new(r_new) in, wherein："-" is that the difference operation of set accords with, and Z non-NULLs；

(5-1-4) judges FDs_new (r_new) in whether also have the minimal functional dependencies that do not read, if so, then repeat step (5- 1-1)~(5-1-3)；If it is not, then enter step (6)；

(5-2) is if t_pIt is the tuple deleted, changes FDs_new (r_new) the step of it is as follows：

(5-2-1) reads FDs_new (r_new) in a minimal functional dependencies f, if f：X → Y,

(5-2-2) if | X |=1, f are in r_newIn be still minimal functional dependencies；

If | X | ＞ 1, for allAnd Z non-NULLs, judge Z → Y in r_newIn whether be minimal functional dependencies, if so, then Increased to FDs_new (r_new) in, and in FDs_new (r_new) in delete f；

If in r_newIn be not present Z → Y be minimal functional dependencies, then judge f in r_newIn whether be still functional dependence, if so, then f In r_newIn be still minimal functional dependencies；If it is not, then in FDs_new (r_new) in delete f；

(5-2-3) reads an attribute A from R, and other newly-increased minimal functional dependencies are calculated using following steps：

(5-2-3-1) is setAnd X non-NULLs, X is not comprising A Non-NULL property set, L=1；

(5-2-3-2) if C non-NULLs,Otherwise, turn (5-2-4)；

(5-2-3-3) if C ' non-NULLs, for each element X in C ', for not in FDs_new (r_new) in X → A, judge it Whether it is minimal functional dependencies, if so, X → A then is increased into FDs_new (r_new) in, and all X ∪ Y elements are deleted in C, WhereinAnd

(5-2-3-4) makes L add 1；

(5-2-3-5) if C non-NULLs, and L<| R | -1, then repeat step (5-2-3-2)~(5-2-3-4)；Otherwise, into step (5-2-4)；

(5-2-4) judges whether also have the attribute not read in R, if so, repeat step (5-2-3)；If it is not, into step (5-2-5)；

(5-2-5) judges FDs_new (r_new) in whether also have the minimal functional dependencies that do not read, if so, then repeat step (5- 2-1)~(5-2-4)；If it is not, then enter step (6)；

(5-3) is if t_pIt is the tuple of modification, for t_pIn each attribute A changed, if t_pIt is expressed as：(v₁,…,(v_A- old,v_A-new),…,v_n), calculate FDs_new (r_new) the step of it is as follows：

(5-3-1) ifBy (v₁,…,v_A- old,…,v_n) as tuple is deleted, change FDs_new (r according to step (5-2)_new)；

(5-3-2) if A ∈ Z | X → Y ∈ FDs_new (r_new), Z=X ∪ Y }, then first by (v₁,…,v_A-old,…,v_n) make To delete tuple processing, FDs_new (r are changed according to step (5-2)_new)；Again by (v₁,…,v_A-new,…,v_n) as increase Tuple processing, FDs_new (r are changed according to step (5-1)_new)；

(6) judge whether the tuple not read also be present in △ r, if so, repeat step (4)~(5)；If it is not, into step (7)；

(7) FDs_new (r are preserved_new) and r_newDivision information collection Partitions_new；

(8) FDs_new (r are exported_new)。

2. the incremental calculation method of minimal functional dependencies according to claim 1, it is characterised in that the initial relation table R least function dependence set and division information is obtained using existing minimal functional dependencies computational algorithm TANE.