Method, system and product for merging objects from a source database into a target database
By maintaining configuration files and dynamically generating SQL queries, the problem of data being distributed in multiple tables in the database is solved, the ability to automatically compare and selectively combine data does not match data is realized, and the intuitive user interface and maintenance of cross-table dependencies is provided. , improves the efficiency and accuracy of database merging.
Patent Information
- Application Number
- CN201980052833.3
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2019-06-14
- Publication Date
- 2024-12-03
- Estimated Expiration
- 2039-06-14
AI Technical Summary
The prior art is difficult to automatically compare two databases and merge mismatched data from one database to another, especially when the data is distributed in multiple relational database tables, multiple tables need to be accessed or merged to present logic. Objects as a single record.
By maintaining configuration files, defining the relationship between logical business objects and their related tables, dynamically generate SQL queries using configuration files to obtain data associated with logical objects, and comparing two databases in the graphical user interface, users can choose to merge Mismatched records. The system ignores irrelevant data identifier differences and maintains all dependencies across relational database tables.
The ability to automatically compare two databases and selectively merge the unmatched data is realized, the dependencies across relational database tables are maintained, and an intuitive user interface is provided to view and merge differences, which improves the flexibility and accuracy of database merging.
Smart Images

Figure CN112654976B_ABST
Abstract
Description
[0001] CROSS-REFERENCE TO RELATED APPLICATIONS
[0002] This application claims priority to Indian Patent Application No. 201841022589, filed on June 16, 2018 in India, entitled “SYSTEM AND METHOD FOR COMPARING AND SELECTIVELY MERGING DATABASE RECORDS” and U.S. Patent Application No. 16 / 104,361, filed on August 17, 2018, entitled “SYSTEM AND METHOD FOR COMPARING AND SELECTIVELY MERGING DATABASE RECORDS”, the entire contents of which are incorporated herein by reference. Technical Field
[0003] The present invention relates generally to database systems and, more particularly, to comparing and selectively merging database records from a source database with a second database. Background Art
[0004] The database stores data of various objects. In some databases, data associated with a particular object may be distributed in multiple relational database tables, wherein one relational database table may cross-reference one or more other relational database tables (herein, for convenience, referred to as parent tables or dependencies). Summary of the invention
[0005] According to one embodiment of the present invention, a method, a database system and a computer program product allow objects to be merged from a source database to a target database, wherein the objects are associated with data stored in multiple relational database tables in the source database. Such a merge involves obtaining a primary key of the object; querying the source database using the primary key of the object to obtain a primary key value from a first relational database table; identifying a parent object associated with the object, the parent object being associated with a second relational database table; obtaining a parent key of the parent object; querying the source database using the parent key to obtain a parent key value from the second relational database; querying the target database using the parent key value to determine whether the parent key value exists in a parent object record in the target database; when the parent key value does not exist in the parent object record in the target database, adding a parent object record containing the parent key value to the target database; and adding an object record including a primary key value and a reference to the parent key value in the parent key record to the target database.
[0006] In various alternative embodiments, querying the source database using the parent key to obtain the parent key value from the second relational database may include joining the first relational database table and the second relational database table. Adding a parent object record including the parent key value to the target database may include assigning an identifier to the parent key value, wherein the identifier is unique in the target database and is different from a corresponding identifier of the parent key value in the source database. In this case, a reference to the parent key value may include a unique identifier assigned to the parent key value. Adding an object record to the target database may involve assigning an identifier to the primary key value, wherein the identifier is unique in the target database and is different from a corresponding identifier of the primary key value in the source database; and when the parent key value exists in the parent object record in the target database, the reference to the parent key value may include an identifier associated with the existing parent key value.
[0007] In any of the above embodiments, the merging may involve maintaining a configuration file that describes data stored in a plurality of relational database tables, the configuration file including primary keys of objects and relationships between the plurality of relational database tables, wherein the primary keys of the objects, identifiers of the parent objects, and the parent keys are obtained from the configuration file. Other embodiments may be disclosed and claimed. BRIEF DESCRIPTION OF THE DRAWINGS
[0008] This patent or application file contains at least one drawing executed in color. Copies of this patent or patent application publication with color drawing(s) will be provided by the Office upon request and payment of the necessary fee.
[0009] The foregoing features of the embodiments will be more readily understood by reference to the following detailed description taken in conjunction with the accompanying drawings, in which:
[0010] Figure 1 An example GUI front-end display is shown showing representations of individual units associated with a group of units called CURRENCY.
[0011] Figure 2 An example table named M_UNITS is shown that defines various units such as currency, weight, etc. according to an exemplary embodiment.
[0012] Figure 3 is an example unit groups table named M_UNIT_GROUPS according to an exemplary embodiment.
[0013] Figure 4 An example source database state and an example target database state including a mismatch of UNIT_ID values are shown according to an example embodiment.
[0014] Figure 5 An example source database state and an example target database state including a parent dependency relationship are shown according to an exemplary embodiment.
[0015] Figure 6 An example source database state and an example target database state including a mismatch in UG_ID values are shown according to an example implementation.
[0016] Figure 7 An example source database state and an example target database state including a mismatch in UG_CODE values are shown according to an example implementation.
[0017] Figure 8 An example source database state and an example target database state are shown, wherein an object in the source database does not exist in the target database, according to an exemplary embodiment.
[0018] Fig. 9 An example source database state and an example target database state are shown, wherein an object in the target database does not exist in the source database, according to an exemplary embodiment.
[0019] Fig.10 An example source database state and an example target database state are shown, wherein an object in the source database does not exist in the target database, according to an exemplary embodiment.
[0020] Fig.11 According to an exemplary embodiment, Fig.10 The result of the join operation between the source database and the target database.
[0021] Fig.12 According to an exemplary embodiment, Figure 10 to Figure 11 Example source database state and example target database state when UG_CODE=WEIGHT is added to the target database.
[0022] Fig.13 According to an exemplary embodiment, Fig.12 Example source database status and example target database status when UNIT_CODE=kg is added to the target database.
[0023] Figures 14 to 16 According to the exemplary embodiment, reference is jointly formed Figures 10 to 13 Flowchart of the described merge process.
[0024] Fig.17 An example source database state and an example target database state are shown, wherein UG_CODE=weight exists in the target database, but UNIT_CODE=kg does not exist in the target database, according to an exemplary embodiment.
[0025] Fig.18 According to an exemplary embodiment, Fig.17 Example source database status and example target database status when UNIT_CODE=kg is added to the target database.
[0026] Fig.19 An example is shown in which a single base record in the base table M_UNITS is associated with multiple records in the extended table M_UNIT_NLS (specifically, extended table records of NLS_ID=1 and NLS_ID=2) according to an exemplary embodiment.
[0027] Fig. 20 Shown according to Fig.19 An example of an implementation of using NLS_ID=1 as a default value.
[0028] Fig.21 Shown according to Fig.19 An example of an implementation of using NLS_ID=2 as a default value.
[0029] Fig. 22 An example database state is shown according to an exemplary embodiment, where there are multiple levels of dependencies that need to be processed in order to compare and merge the databases.
[0030] Fig.23 According to an exemplary embodiment, Fig. 22 Example source database state and example target database state when X_CODE=PHYSICAL is added to the target database.
[0031] Fig.24 According to an exemplary embodiment, Fig.23 Example source database state and example target database state when UG_CODE=weight is added to the target database.
[0032] Fig.25 According to an exemplary embodiment, Fig.24 Example source database status and example target database status when UNIT_CODE=kg is added to the target database.
[0033] Fig.26 An example source database state and an example target database state are shown, wherein objects have multiple dependencies at the same level, according to an exemplary embodiment.
[0034] Fig. 27 According to an exemplary embodiment, Fig.26Example source database state and example target database state when X_CODE=PHYSICAL and UG_CODE=WEIGHT are added to the target database.
[0035] Fig.28 According to an exemplary embodiment, Fig. 27 Example source database status and example target database status when UNIT_CODE=kg is added to the target database.
[0036] Fig.29 is an annotated screenshot showing an example Data Comparison window for S3D information according to an exemplary embodiment.
[0037] Fig.30 is a screenshot illustrating an example data comparison window for Transfer Jobs information according to an exemplary embodiment.
[0038] Fig.31 is a screenshot illustrating an example data comparison window for Notes information according to an exemplary embodiment.
[0039] Fig.32 is a screenshot illustrating an example data comparison window in which all displayed records are identical in both databases in accordance with an exemplary embodiment.
[0040] Fig.33 is a screenshot showing four active SDB Merge Tool windows according to an exemplary embodiment.
[0041] Fig.34 is a screenshot illustrating an example Object Dependency Hierarchy window in accordance with an illustrative embodiment.
[0042] Fig.35 is a screenshot showing an Export to Excel window in a first format according to an exemplary embodiment, wherein records are sorted by Same, Source Only, Target Only, and Different.
[0043] Fig.36 is a screenshot showing an Export to Excel window in a second format with individual differences highlighted in accordance with an exemplary embodiment.
[0044] It should be noted that the aforementioned figures and the elements depicted therein are not necessarily drawn to consistent scale or to any scale. Unless the context dictates otherwise, the same elements are represented by the same numerals. DETAILED DESCRIPTION
[0045] Embodiments of the present invention allow source and target databases to be compared and merged in such a way that logically related data is considered and merged while ignoring irrelevant differences (e.g., object identifiers, which in this context refer to the serial number / identifier (ID) of the database table), and all dependencies across relational database tables are considered and merged. Reference is made herein to Intergraph Smart TM Some exemplary embodiments are discussed with reference to a database such as the Standard Database of Data Products (SDB) and are generally referred to as the "SDB Merge Tool," although the disclosed concepts may be more generally applicable to other types of databases.
[0046] The technical problem underlying the present invention can be viewed as providing a method for automatically comparing two databases, identifying differences between the two databases, and merging unmatched data from one database (referred to herein as the "source" database) to another database (referred to herein as the "target" database). Typically, data associated with a logical (business) object will be distributed across multiple relational database tables within a database (sometimes referred to as "normalization"), so that multiple tables need to be accessed or merged in order to present a specific logical (business) object as a single record to a user who does not understand the underlying database structure and design. Therefore, an exemplary embodiment defines each logical (business) object in a configuration file that lists the tables associated with the logical business object and the relationships between the tables. The information provided in the configuration file can be used to form a record of a specific logical (business) entity, for example, by identifying related tables and accessing or connecting these tables to obtain all the data required for the record. Then, the record from one database can be compared with another database. A graphical user interface can be provided to show how the two databases are compared (e.g., identifying differences in general or according to specific types of differences). For example, the differences can be displayed side by side in a data grid view. According to such a graphical user interface, a user can cause data from a source database to be merged into a target database (e.g., by selecting an unmatched record in a grid and saving the record to the target database). Importantly, such a merge of data from a source database to a target database maintains all dependencies across relational database tables.
[0047] SDB Merge Tool is a web-based tool that will provide the ability to view / compare two Standard Database (SDB) databases and provide the differences in a user-intuitive data grid interface. The user can view the differences in a side-by-side data grid, select the data to be merged and save the data into the database. The tool provides the flexibility to selectively merge and save the required content from one database to another.
[0048] Some features of an exemplary SDB merge tool include:
[0049] ●Intuitive web-based user interface to view differences in a side-by-side data grid and merge desired data from one SDB database to another.
[0050] ● Synchronized horizontal and vertical scrolling, filtering, sorting, column resizing of both source and target grids.
[0051] ● Ability to automatically identify mandatory parent dependencies required to merge selected data into the target database. If a child business object is saved, the mandatory parent business object is also saved to the target database if an existing mandatory parent business object does not exist in the target database.
[0052] ● The ability to select a high-level business object and merge it with its child dependency data into a target database.
[0053] ●The ability to configure the business object hierarchy structure tree based on the data model.
[0054] ● The ability to report data from both databases into an Excel file. The user can click on a node and report the data associated with that object. The data for each attribute value is reported side by side. This enables easy comparison of data differences.
[0055] Example SDB System
[0056] Typically, an SDB system will include a relational database backend in which data is stored in various relational database tables, and a graphical user interface (GUI) frontend that allows a user to visualize and manipulate the data. Typically, the GUI frontend hides many of the details of the data stored in the relational database tables. For example, a particular logical (business) object (e.g., a product such as a pipe) may be based on data distributed across multiple relational database tables (e.g., manufacturer, material, length, inner diameter, outer diameter, threads, cost, weight, etc.), but the GUI frontend typically allows the user to view and manipulate information about the object without requiring the user to know anything about the underlying tables or how the data is stored in the tables.
[0057] For example, a particular SDB system may define various units for specifying logical (business) objects (e.g., currencies such as Australian dollars and Canadian dollars, weights such as kilograms and pounds, area units such as square meters and square feet, etc.). Within the SDB backend, these units may be stored in a relational database table (e.g., referred to herein as a "Unit" table). The SDB backend may define various unit groups (e.g., unit groups named "currency", "weight", "area", etc.) in a separate relational database table (e.g., referred to herein as a "UnitGroup" table). Within the SDB, various units and unit groups may be assigned unique identifiers (e.g., digital identifiers). For example, for each unit, by storing the identifier of the associated unit group from the unit group table in the unit table, each unit in the unit table may be associated with one of the multiple unit groups in the unit group table (e.g., the units Australian dollars and Canadian dollars may be associated with a unit group called "currency", the units kilograms and pounds may be associated with a unit group called "weight", the units square meters and square feet may be associated with a unit group called "area", etc.).
[0058] Figure 1 An example GUI front-end display is shown, which shows representations of individual units associated with a unit group called CURRENCY. Here each unit has various properties that the user can see, including:
[0059] ●Unit Group
[0060] ●Unit
[0061] ●Short Desc
[0062] ●Description
[0063] ●Precision
[0064] These attributes are stored along with other data in various relational database tables in the SDB backend.
[0065] Figure 2 An example table named M_UNITS according to an exemplary embodiment is shown, which defines various units such as currency, weight, etc. Here, the M_UNITS table includes the following columns:
[0066] ●UNIT_ID: Primary key. It is a sequence value.
[0067] ●UG_ID: ID of the unit group, which is stored in a different table.
[0068] ●UNIT_CODE: Direct attribute. Unit.
[0069] USR_ID: Direct attribute. Last modified user.
[0070] ●LMOD: Direct attribute. Last modification time.
[0071] ●INT_REV: Direct attribute. Updated sequence number.
[0072] ●PRECISION: Direct attribute. Precision.
[0073] ●SDB_INFO: Direct attributes. SDB Information - User can add custom data in this field.
[0074] Note that column UG_ID includes a reference to an independent unit group table (not shown). Specifically, units kg / m and kg / 1000pc are associated with a unit group with unit group ID (UG_ID) 5012, unit deg is associated with a unit group with unit group ID (UG_ID) 5008, unit m2 / UOM is associated with a unit group with unit group ID (UG_ID) 5000, and units AED and AUD are associated with a unit group with unit group ID (UG_ID) 5007.
[0075] The M_UNITS table does not have data on unit group attributes. Therefore, it is necessary to obtain data on unit group attributes by connecting to the unit group table. Figure 3 is an example unit group table named M_UNIT_GROUPS according to an exemplary embodiment. As in the M_UNITS table, the M_UNIT_GROUPS table will typically contain additional columns (not shown for convenience), including, for example,
[0076] ●Last modified user.
[0077] ●Updated serial number.
[0078] ●Last modification time.
[0079] Some of the data required by the M_UNIT_GROUPS table may have to be obtained by joining with one or more other tables.
[0080] Furthermore, the M_UNITS table does not have Figure 1 The data of the Short Desc and Description fields displayed in the GUI front-end display of , therefore needs to be obtained by joining with one or more other tables (for example, accessed using the UNIT_ID field of the M_UNITS table).
[0081] It should be noted that Figure 1 The GUI front-end display hides information about the underlying relational database tables and how data is stored in the tables. Therefore, users can work at the object level while the SDB system handles all relational database operations in the background.
[0082] Compare the source SDB database and the target SDB database
[0083] Sometimes it may be necessary or desirable to compare two SDB databases. In this regard, an SDB merge tool needs to compare the meaning of the data rather than, for example, object identifiers, and needs to take into account dependencies that extend across relational database tables. For example, suppose the source and target databases consist of Figure 4 Entries shown. Note that the source database associates UNIT_ID=5440 with UNIT_CODE=kg / m, while the target database associates UNIT_ID=5440 with UNIT_CODE=deg. Therefore, it appears that the two databases do not match with respect to this object. However, in an exemplary embodiment, this identifier mismatch is not considered a mismatch between the two databases because the SDB merge tool compares UNIT_CODE with UNIT_CODE, rather than comparing UNIT_ID with UNIT_ID. Therefore, in this example, the SDB merge tool compares (UNIT_CODE=kg / m, UNIT_ID=5440) with (UNIT_CODE=kg / m, UNIT_ID=5304) and identifies a match, rather than comparing (UNIT_CODE=kg / m, UNIT_ID=5440) with (UNIT_CODE=deg, UNIT_ID=5440) and incorrectly identifying a mismatch.
[0084] In an exemplary embodiment, the SDB merge tool must go a step further in order to compare the two databases, especially when objects have dependencies across relational database tables (such as the dependencies between units in the M_UNITS table and unit groups in the M_UNIT_GROUPS table in the above example). Now assume that the source database and the target database include Figure 5 Here, the SDB merge tool can determine not only that UNIT_CODE=kg / m exists in both databases, but also that each database associates UNIT_CODE=kg / m with a unit group having UG_CODE=weight. Thus, the SDB merge tool can determine that the two databases match with respect to this object.
[0085] Similarly, the SDB merge tool can determine not only that UNIT_CODE = deg exists in both databases, but that each database associates UNIT_CODE = deg with a unit group having UG_CODE = temperature. Thus, the SDB merge tool can determine that the two databases match with respect to this object.
[0086] In order to perform this comparison, the SDB merge tool must obtain the logical data associated with each logical (business) object by connecting the appropriate tables. In the above example, for example, in order to obtain the logical data associated with the units kg / m and deg, the SDB merge tool must connect the M_UNITS table and the M_UNIT_GROUPS table.
[0087] Similar to the mismatch in the UNIT_ID of the unit kg / m in the two databases above, the UG_ID of the unit group may also not match. Assume that the source and target databases include Figure 6 Entries shown. Here, even though the unit group identifiers for weight (WEIGHT) and temperature (TEMPERATURE) in the target database do not match the unit group identifiers in the source database, the SDB merge tool can determine not only that UNIT_CODE=kg / m exists in both databases, but also that each database associates UNIT_CODE=kg / m with a unit group having UG_CODE=weight, because the SDB merge tool compares unit codes rather than unit identifiers. Therefore, the SDB merge tool can determine that the two databases match with respect to the object.
[0088] Similarly, the SDB merge tool can determine not only that UNIT_CODE=deg exists in both databases, but also that each database associates UNIT_CODE=deg with a unit group having UG_CODE=temperature because the SDB merge tool compares unit codes rather than unit identifiers. Thus, the SDB merge tool can determine that the two databases match with respect to the object.
[0089] It is also possible that a particular unit will match in both databases, but the parent dependency (i.e., the unit group in this example) will not match. Assume that the source and target databases include Figure 7 Entries shown. Here, the unit with UNIT_CODE=deg exists in both databases, but is associated with the unit group temperature (TEMPERATURE) in the source database and the unit group angle (ANGLE) in the target database. Since the SDB merge tool compares objects including all their dependencies, the SDB database can identify a mismatch when it compares the user group of units with UNIT_CODE=deg.
[0090] Of course, there may be objects in the source database that do not exist in the target database. Figure 8 Here, the target database does not include a unit with UNIT_CODE=deg. When the SDB merge tool searches for a unit with UNIT_CODE=deg in the target database, it can identify this mismatch.
[0091] Similarly, objects may exist in the target database that do not exist in the source database. Fig. 9 Here, the source database does not include a unit with UNIT_CODE=deg. The SDB merge tool can identify this mismatch when it searches the source database for a unit from the target database with UNIT_CODE=deg, or by otherwise identifying any objects in the target database that were not accessed when comparing objects from the source database to the target database.
[0092] Therefore, during the comparison of two databases, each logical (business) object may be classified into one of the following different categories:
[0093] = Identical - the object exists in both the source and target databases, and all properties match in both databases.
[0094] ● Source Only - The object exists in the source database but not in the target database.
[0095] ● Target Only - The object exists in the target database but not in the source database.
[0096] = Different - The object exists in both the source and target databases, but a few attributes do not match.
[0097] Configuration Files
[0098] As described above, in order to obtain the logical data associated with each logical (business) object so that the databases can be compared, the SDB merge tool may have to connect multiple tables. In a typical SDB database, it is impractical to write and maintain SQL queries that compare all logical objects associated with the SDB database. Therefore, in an exemplary embodiment, the SDB merge tool maintains a configuration file that defines the logical object structure of the SDB database including logical dependencies. The SDB merge tool generates executable queries in the form of dynamic insert and update scripts based on the configuration file to compare and copy database objects.
[0099] In an exemplary embodiment, each logical (business) object is defined by a BODefinition element, which contains the object name, the base table used to obtain data from the database, and an optional display name displayed in the user interface. It also defines a list of attributes, a primary key, and unique attributes.
[0100] The following is an example BODefinition definition according to an exemplary implementation:
[0101] Name: A property that defines the logical object name (Name). It is unique to the entire configuration.
[0102] BaseTable: Defines the characteristics of the main table in the database that defines object data.
[0103] DisplayName: Optional attribute that defines the name to be displayed in the user interface. If not defined, the Name value is used.
[0104] PrimaryKey: An element that defines the primary key of a logical object.
[0105] UniqueKey: An element that defines a unique key for a logical object.
[0106] Properties: Elements that define the properties of a logical object.
[0107] The following is an example PrimaryKey definition according to an exemplary implementation:
[0108] PrimaryKey: An element that defines the primary key of a base table. It contains a list of columns that are part of the primary key.
[0109] PrimaryKeyColumn: Defines the element of the primary column.
[0110] Column of PrimaryKeyColumn: defines the characteristics of the column name.
[0111] Sequence of PrimaryKeyColumn: Defines the characteristics of the sequence used to get the next value. Sequence is optional if the column is defined as a primary key in the parent table.
[0112] The following is an example UniqueKey definition according to an exemplary implementation:
[0113] UniqueKey: An element that defines the attributes of a partial unique key for a logical object. It contains a list of attributes that are part of the unique key.
[0114] UniqueProperty: An element that defines a unique property.
[0115] UniqueProperty's Name: Attribute that defines the unique property name.
[0116] The following are example property definitions according to an exemplary implementation:
[0117] Properties: An element that defines the properties of a logical object. It contains a list of property elements.
[0118] Property: An element that defines a single property of a logical object.
[0119] Property Name: Defines the properties of the property name.
[0120] DbColumn of Property: Defines the characteristics of the database column in which the data of the property is defined.
[0121] UseForProperty of a Property: A property that defines whether the property should be used for comparison of logical objects.
[0122] ExtensionColumn Property: A property that defines the column name of the extension table in which the data is defined.
[0123] ExtensionTable of Property: Defines the property of the table name that contains additional information of the logical object in addition to the base table. When only columns are needed to connect to the extension table, and the column names in the extension table and the base table are the same, you can use ExtensionTable to define the extension table relationship. Otherwise, use the Extension element.
[0124] Property's ParentName: A property that defines the column name in the parent object that defines the data.
[0125] ParentBO of Property: A property that defines the name of the parent logical object. The actual data is defined in it. When only one level of the parent hierarchy is required and the column names in both the parent and base tables are the same, ParentBO can be used for definition. Otherwise, use the Parent element. This allows the definition of the parent relationship to be handled briefly.
[0126] The following is an example Join definition according to an exemplary implementation:
[0127] Join: An element that defines how to connect two tables.
[0128] Join Column: defines the characteristics of the join column from the base table.
[0129] JoinColumn of Join: defines the characteristics of the join column from the parent table / extended table.
[0130] DefaultValue of Join: Defines the characteristics of the default record used in the join operation when the extended table defines multiple data records for a single base table record. Fig.19 An example is shown in which a single base record in the base table M_UNITS is associated with multiple records in the extension table M_UNIT_NLS (specifically, extension table records with NLS_ID = 1 and NLS_ID = 2). The default value specifies which extension table record should be used if the user does not specify one. Fig. 20 An example is shown in which NLS_ID=1 is used as a default value. Fig.21 An example is shown in which NLS_ID=2 is used as a default value.
[0131] Example Configuration File Schema
[0132] The following is an example configuration file schema for configuration xml according to an exemplary embodiment:
[0133] <? xml version="1.0" encoding="utf-8"? >
[0134] <xs:schema attributeFormDefault="unqualified"elementFormDefault="qualified"
[0135] xmlns:xs="http: / / www.w3.org / 2001 / XMLSchema">
[0136] <xs:element name="BODefinitions">
[0137] <xs:complextype>
[0138] <xs:sequence>
[0139] <xs:element maxOccurs="unbounded"name="BODefinition">
[0140] <xs:complextype>
[0141]
[0142]
[0143]
[0144] use="optional" / >
[0145] < / xs:complextype>
[0146]
[0147] < / xs:sequence>
[0148] < / xs:complextype>
[0149]
[0150]
[0151] <xs:attribute name="Name"type="xs:string"use="required" / >
[0152] <xs:attribute name="BaseTable"type="xs:string"use="required" / >
[0153] <xs:attribute name="DisplayName"type="xs:string"use="optional" / >
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160] Sample Configuration File
[0161] The following is in reference Figures 1 to 9 An example configuration file showing and describing the type of relational database tables used in the examples:
[0162] <? xml version="1.0" encoding="utf-8"? >
[0163] <bodefinitions>
[0164] <BODefinition Name="UnitGroup"BaseTable="M_UNIT_GROUPS">
[0165] <primarykey>
[0166] <PrimaryKeyColumn Column="UG_ID"Sequence="M_SEQ_UG_ID" / >
[0167] < / primarykey>
[0168] <uniquekey>
[0169] <UniqueProperty Name="UG_CODE" / >
[0170] < / uniquekey>
[0171]
[0172]
[0173]
[0174]
[0175] Query generation for comparison and merging
[0176] Using the BODefinition defined in the configuration file, the SDB Merge Tool dynamically prepares appropriate SQL queries to obtain data associated with logical (business) objects and compares the data from the two databases and classifies the data objects appropriately, which will be discussed in more detail below.
[0177] The following are some examples of generating queries to retrieve data associated with a logical object. In these examples, BaseTable is the main table for the business object and is given an alias (e.g., bt). The top-level query is formed as follows:
[0178] select{column_list}from M_UNITS bt
[0179] The list of columns reached is as follows. For each attribute, there is a column with an alias in the list of columns. A sample query to retrieve data for different attributes is as follows.
[0180] Case 1: Attribute defined directly in the base table. The DbColumn from the base table is used as the selector and the Name can be used for the alias.
[0181] For example:<Property Name="UG_CODE"DbColumn="UG_CODE" / >
[0182] The column will be bt.UG_CODE UG_CODE
[0183] Case 2: Attributes with values defined by the parent table joined by columns, for example:
[0184] For example:
[0185]
[0186] By joining the columns from the base table and the parent table, you can select the ParentName value from the base table in ParentBo. The Name value is used as an alias.
[0187] If multiple parents are present, they are concatenated to get the value of the property, for example:
[0188]
[0189] Case 3: Attributes defined in an extension table. Select the extension column from the extension table by joining the columns of the base table and the extension table. The Name value used as an alias, for example:
[0190]
[0191] The database functions of union, intersect, and minus are used to compare data and classify logical objects. Specifically, a database link is created to connect one database to another (i.e., source to target and target to source). When querying a table, a suffix or prefix can be added to the table name, such as table@remote_link, remote_link.table.
[0192] The following notation is used in the following "skeleton" queries for the various categories:
[0193] ●all_properties is a list of columns containing all properties
[0194] compare_properties is a list of columns containing comparable properties
[0195] unique_properties is a list of columns containing the properties that are part of the unique key
[0196] null_columns is a list of columns that define null values. This is used to match the number of columns in all subqueries of the union query.
[0197]
[0198]
[0199]
[0200] To obtain records of all categories, all the above queries can be combined using a union, or a single category result can be queried. Based on the Relational Database Management System, the query can have variations and can be adjusted to obtain better performance.
[0201] The following are sample queries for comparing and getting data from the source SDB database:
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215] Example - Merge object and parent into target
[0216] The following is an example of merging objects that exist in the source database but not in the target database. Assume that the source and target databases include Fig.10 . Here, the source database includes a unit with UNIT_CODE=kg that does not exist in the target database. For simplicity, only unique attribute and primary key data are shown. As described above, this mismatch can be presented to the user through a graphical user interface. The user can choose to save the object from the source database into the target database, in which case the SDB merge tool merges the relevant data from the source database into the target database.
[0217] In an exemplary embodiment, the SDB merge tool first connects the appropriate tables based on the configuration files. Fig.11 The result of the connection operation of the source database and the target database according to this example is shown.
[0218] Based on the results of the join operation, the SDB merge tool can identify that the unit with UNIT_CODE = kg exists in the source database but does not exist in the target database. The SDB merge tool can also identify that the unit with UNIT_CODE = kg has a parent with UG_CODE = weight in the unit group table, but there is no unit group with UG_CODE = weight in the target database. Therefore, the SDB merge tool adds the unit group with UG_CODE = weight to the target database, resulting in Fig.12 The database status shown. Note that a unit group identifier (UG_ID) 22 is added in the unit group with UG_CODE=weight, which is unique in the target database and different from UG_ID 20 for UG_CODE=weight in the source database. This is because UG_ID=20 may already be used in the target database in association with some other unit group.
[0219] After adding the unit group with UG_CODE = weight to the target database, the SDB merge tool adds the unit with UNIT_CODE = kg to the target database, resulting in Fig.13 The database status shown. Note that the target database has a unique UNIT_ID=1007 added to the unit with UNIT_CODE=kg, whereas the source database has a unique UNIT_ID=1003 added to the unit with UNIT_CODE=kg. This is because UNIT_ID=1003 may have been used in association with some other unit in the target database.
[0220] As a result, the source and target databases now match with respect to the object. Note that the unit group dependencies are automatically inserted into the target database along with the units.
[0221] Figures 14 to 16 According to the exemplary embodiment, the flowchart of the above-mentioned merging process is formed together. In box 1402, the SDB merging tool obtains the unique key attribute of the unit object based on the configuration file, in this example, the unique key attribute is a unit with UNIT_CODE=kg. In box 1404, the SDB merging tool obtains the primary key of the unit object based on the configuration file, in this example, the primary key is UNIT_ID. In box 1406, the SDB merging tool then uses the unique key to query the source database, in this example, the unique key is UNIT_CODE=kg. Then, in box 1408, the SDB merging tool checks whether the object has any parent object based on the configuration file. In this example, the unit object has a parent unit group (that is, yes in box 1408). Therefore, in box 1410, the SDB database obtains the unique key parent object based on the configuration file, in this example, the unique key parent object is UG_CODE. Then, in box 1412, the SDB merging tool obtains the parent unique key value from the source database by connecting with the UG_ID defined in the configuration file. Then, in box 1414, the SDB merge tool uses the obtained parent unique key value to query the target database, in this example, the parent unique key value is UG_CODE=Weight. Then, in box 1416, the SDB merge tool determines whether the UG_CODE=Weight record is available in the target database. In this example, the UG_CODE=Weight record is not available in the target database (i.e., no in box 1416), so the SDB merge tool returns to box 1408 to check whether the UG_CODE=Weight object has any parent object. In this example, the UG_CODE=Weight object does not have any parent object (no in box 1408), so the SDB merge tool proceeds to box 1418, in which the SDB merge tool inserts the UG_CODE=Weight box into the M_UNIT_GROUPS table of UG_ID=22, as shown in FIG. Fig.12 Then, in block 1420, the SDB merge tool determines the value of the primary key (ie, UNIT_ID = 1007), and in block 1422, adds the record to the M_UNITS table, resulting in Fig.13 The database status is shown.
[0222] Example - Merge an object into a target using an existing parent
[0223] As a variation of the above example, the target database may already include a unit group with UG_CODE=weight, e.g. Fig.17 As shown. In this case, the SDB merge tool can recognize that the unit with UNIT_CODE=kg exists in the source database, but does not exist in the target database. The SDB merge tool can also recognize that the unit with UNIT_CODE=kg has a parent in the unit group with UG_CODE=weight, and can also recognize that the unit group with UG_CODE=weight exists in the target database, albeit with a different UG_ID. Therefore, the SDB merge tool can use the existing unit group with UG_CODE=weight to add the unit with UNIT_CODE=kg to the target database, resulting in Fig.18 The database status is shown.
[0224] Reference again Figures 14 to 16 In box 1402, the SDB merge tool obtains the unique key attribute of the unit object based on the configuration file, in this example, the unique key attribute is the unit with UNIT_CODE=kg. In box 1404, the SDB merge tool obtains the primary key of the unit object based on the configuration file, in this example, the primary key is UNIT_ID. In box 1406, the SDB merge tool then uses the unique key to query the source database, in this example, the unique key is UNIT_CODE=kg. Then, in box 1408, the SDB merge tool checks whether the object has any parent objects based on the configuration file. In this example, the unit object has a parent unit group (i.e., yes in box 1408). Therefore, in box 1410, the SDB database obtains the unique key parent object based on the configuration file, in this example, the unique key parent object is UG_CODE. Then, in box 1412, the SDB merge tool obtains the parent unique key value from the source database by connecting with the UG_ID defined in the configuration file. Then, in box 1414, the SDB merge tool uses the obtained parent unique key value to query the target database, in this example, the obtained parent unique key value is UG_CODE=weight. Then, in box 1416, the SDB merge tool determines whether the UG_CODE=weight record is available in the target database. In this example, the UG_CODE=weight record is available in the target database (i.e., yes in box 1416), so the SDB merge tool proceeds to box 1420, in which the SDB merge tool determines the value of the primary key (i.e., UNIT_ID=1007) and adds the record to the M_UNITS table in box 1422, resulting in Fig.18 The database status is shown.
[0225] Example - Multiple levels of dependencies
[0226] Fig. 22 An example database state is shown in which there are multiple levels of dependencies that need to be addressed in order to compare and merge the databases. Specifically, in this example, the M_UNITS table depends on the M_UNIT_GROUPS table, and the M_UNIT_GROUPS table depends on the X table, which classifies unit groups AREA and WEIGHT as spatial attributes and classifies unit group WEIGHT as a physical attribute (for example purposes only). The SDB Merge Tool recognizes that the target database lacks a unit with UNIT_CODE=kg, recognizes that the target database also lacks the associated unit group with UG_CODE=weight, and recognizes that the target database also lacks the associated category with X_CODE=PHYSICAL. Therefore, the SDB Merge Tool first adds a category with X_CODE=PHYSICAL and X_ID=67 to the target database, resulting in Fig.23 The SDB merge tool then adds the unit group with UG_CODE = weight and UG_ID = 69 to the target database, resulting in Fig.24 The SDB merge tool then adds the unit with UNIT_CODE = kg and UNIT_ID = 1007 to the target database, as shown in Fig.25 In this way, the unit is added with all its dependencies.
[0227] It should be noted that this processing and reference Figures 14 to 16 The process described can generally be represented as a recursive process using the following pseudo code, which is initially called with the primary key of the object obtained from the configuration file (e.g., for the above example, the primary key associated with the unit object with UNIT_CODE=kg):
[0228]
[0229] Thus, in this example, the Merge function will initially be called with a key of UNIT_CODE=kg. This first iteration of the Merge function will determine that the key has a parent (i.e., UG_CODE=weight), and will therefore call the Merge function with a key of UG_CODE=weight. The second iteration of the Merge function will determine that the key has a parent (i.e., X_CODE=physical), and will therefore call the Merge function with a key of X_CODE=physical. The third iteration of the Merge function will determine that the key has no parent. It will then check whether X_CODE=physical exists in the target database, and if not, add a record of X_CODE=physical to the target database. In any case, the third iteration will end and return to the second iteration, which will check whether UG_CODE=weight exists in the target database, and if not, add a record of UG_CODE=weight to the target database. In any case, the second iteration will end and return to the first iteration, which will check whether UNIT_CODE=kg exists in the target database, and if not, add a record of UNIT_CODE=kg to the target database. At the end of the first iteration, objects have been merged from the source database to the target database.
[0230] Similar processing and similar recursion can be applied to situations where a particular object has multiple dependencies at the same level. For example, Fig.26 An example database state is shown in which there are multiple dependencies in the M_UNITS table that need to be processed in order to compare and merge both databases. Specifically, in this example, the M_UNITS table depends on the M_UNIT_GROUPS table that associates individual units with unit groups, and on the X table (for example purposes only) that classifies individual units as spatial attributes or physical attributes. The SDB Merge Tool recognizes that the target database lacks a unit with UNIT_CODE=kg, recognizes that the target database also lacks an associated unit group with UG_CODE=weight, and recognizes that the target database also lacks an associated category with X_CODE=physical. Therefore, the SDB Merge Tool first adds a category with X_CODE=physical and X_ID=67 to the target database, and also adds a unit group with UG_CODE=weight and UG_ID=69 to the target database, resulting in Fig. 27 The SDB merge tool then adds the unit with UNIT_CODE = kg and UNIT_ID = 1007 to the target database, as shown in Fig.28 In this way, the unit is added with all its dependencies.
[0231] In this example, the merge function will initially be called with a key of UNIT_CODE=kg. The first iteration of the merge function will determine that the key has two parents (i.e., UG_CODE=weight and X_CODE=physical), and will therefore call the merge function with a key of UG_CODE=weight and will call the merge function with a key of X_CODE=physical. These iterations of the merge function will add records of X_CODE=physical and UG_CODE=weight to the target database, and will return to the first iteration, which will check whether UNIT_CODE=kg exists in the target database, and if not, will add a record of UNIT_CODE=kg to the target database. At the termination of the first iteration, the objects have been merged from the source database to the target database.
[0232] Example SDB Merge Tool UI
[0233] In an exemplary embodiment, the SDB Merge Tool is a web-based tool that provides the ability to view / compare two Intergraph Smart Reference Data (SDB) databases and present the differences in a user-intuitive data grid interface. The user can view the differences, select the data to be merged, and save the data to the target database. The tool provides the flexibility to selectively merge and save the desired content from one database to another.
[0234] Often, SDB users require an updated set of content available in an SDB release. The SDB Merge Tool provides the ability to compare and view the differences between an SDB release and a customer database, and also provides the flexibility to merge and save a selective set of content from an SDB release into a customer database without disturbing any other content in the customer database.
[0235] Some of the capabilities of the SDB Merge Tool include:
[0236] ●Intuitive web-based user interface to select, view and merge required data from one SDB database to another.
[0237] =The SDB Merge Tool automatically identifies mandatory parent (upstream) dependencies required to merge the selected data.
[0238] ●The user can select a set of records and merge all selected records with all required dependency data into the target database in one step.
[0239] ● The tool provides reporting of data from both databases into a spreadsheet file (e.g., Microsoft EXCEL TM The ability to create a spreadsheet (hereinafter referred to as "Excel") in the same file format as the SQL Server 2003 spreadsheet. Users can click on a node and report the data related to that object. Data for individual characteristic values is reported side by side. This enables users to easily compare data differences. This feature helps identify the exact SDB upgrade changes during the migration process.
[0240] So that the user can select the desired changes and merge them into the target.
[0241] Thus, by using the SDB Merge Tool (a web-based tool), users can see all the data differences between the source (e.g., SDB 2018) database and the target (e.g., Customer) database in an intuitive manner. This allows users to select only the data required for merging into the target database. Since this is a web-based tool, users can merge data from any machine in the same network that has a compatible browser.
[0242] In an exemplary embodiment, the SDB Merge Tool is mainly divided into three views and key functions on the header view and footer view, as follows:
[0243] ●Object Hierarchy view
[0244] Data Comparison View
[0245] Details view
[0246] In an exemplary embodiment, it is only possible to merge data from a source database to a target database using the SDB merge tool. All records that are only for the target will remain unchanged and will not be affected by the merge process.
[0247] The Object Hierarchy View consists of a hierarchy of modules through which the user can navigate to the tree nodes and select the required data and merge it into the target database. Some of the features available in the Object Hierarchy View include:
[0248] ● Expand / Collapse buttons are available on the object hierarchy. The user can use the keyboard arrow keys (or mouse clicks) to navigate to different nodes.
[0249] ●Only one node can be selected at a time, and the selected node will be highlighted in blue.
[0250] ●All names are in bold, indicating parent / hierarchy nodes.
[0251] ●All child nodes / leaf nodes will be displayed in standard font.
[0252] ●When the mouse hovers over the tree hierarchy, the node will be highlighted in light blue.
[0253] ●When the user clicks on a hierarchy node that has other child nodes and no related data, a message "Open child nodes to view data" will be displayed to the user.
[0254] ●Users can hide / unhide the object hierarchy view by clicking on the "Auto Hide" pinned button in the tool. Once the hierarchy is hidden, the tool will appear as "HIERARCHY" with the auto hide button in the left top corner.
[0255] ●All identical records in the source and target databases are displayed in a hierarchical structure without any background color.
[0256] ●All "Source Only" and "Target Only" records displayed in the Object Hierarchy View will be highlighted in green text.
[0257] ●If the record only exists in the source database, it will have an (S) flag appended to the end of the record.
[0258] ● If a record exists only in the target database, then it will have a (T) tag appended to the end of the record. ● All distinct records displayed in the Object Hierarchy View will be displayed in orange text.
[0259] The Data Compare view displays the data between the source and target databases side by side. Some of the features available in the Data Compare view include source and target data grids, data filter controls, and merge controls.
[0260] Here is a summary of the source and target data grids:
[0261] = The connected database details will be shown on the source and target grids in the middle view along with the selected parent node and data node details in the hierarchy view.
[0262] When the user selects a data node in the Object Hierarchy View, the data available for that node in both the source and target will be displayed in the Data Comparison View in the following color format:
[0263] оAll highlighted identical record rows will not have any color.
[0264] оAll source-only or target-only record rows will be highlighted with a green background color.
[0265] оAll different record rows will be displayed with an orange background color.
[0266] ●The same data records in both databases are displayed in the same row of the data grid.
[0267] ●When the user scrolls horizontally or vertically, the changes will be reflected in both grids synchronously, allowing comparable data in the columns to be seen side by side in both grids.
[0268] ● Use mouse click or keyboard up / down arrows to select source / destination grid rows where rows are highlighted in blue.
[0269] ●When you hover over the source / destination grids, the rows will be highlighted in light blue.
[0270] Following is an outline of the data filter control:
[0271] =The user can select / deselect data filters (discussed below) that can be seen at the top of the source and target data grids to filter the data being displayed.
[0272] ●If you select the "Same" check box, the records that exist in both the source and target databases and have no difference in values are displayed in the grid.
[0273] ●If you select the Different check box, the records that exist in both the source and target databases and have different values are displayed in the grid.
[0274] ●When you select the Source Only check box, records that exist in the source database but not in the target database are displayed in the grid.
[0275] ●If you select the Target Only check box, records that exist in the target database but not in the source database are displayed in the grid.
[0276] ●Selection / deselection of these data filter combinations will display the appropriate data according to the selected data filters.
[0277] Here is a summary of the merged controls:
[0278] ● MERGE - The user can merge one or more records by selecting records from the source grid to the target grid. This button will be enabled only when applicable (at least only one source is selected or different records are selected). Using the Merge button will only display the intended merge operation in the data grid. It will not save the changes to the target database.
[0279] ● UNMERGE - Once the user merges data from the source database to the target database and clicks "UNMERGE", the merged data will be unmerged (one step back). Using the "UNMERGE" button will only display the scheduled unmerge operation in the data grid. It will not save the changes to the target database.
[0280] ● UNDO - Applies to any number of back actions. Similar to the "CTRL+Z" function on a source to target merge activity. Using the "Undo" button will only display the intended undone actions in the data grid. It will not save the changes to the target database.
[0281] ● MERGE / UNMERGE / UNDO will not be enabled for all "same" records and "target only" records. It will be enabled for "source only" records and "different" records.
[0282] =REFRESH—Get the latest data available at that point in time for both the source and target databases, and reload the corresponding data grids.
[0283] =EXCEL REPORT—Generates an Excel report of the data objects displayed in the data grid.
[0284] ●DELETE AND REPLACE - Available only for a few data objects that do not support selective data merge. It will replace all data in the target database with the source database data for the object.
[0285] The Details View displays the differences in attribute values between the source and target databases side by side for the selected row. Some of the features available in the Details View include:
[0286] ●All "same" records will be displayed without any colored background.
[0287] ●All "different" records will be displayed with an orange background.
[0288] ●All "Source Only" records and "Target Only" records will be displayed with a green background.
[0289] ●LMOD (Last Modified Date), User (Modified User), and Int_Rev (Modified Sequence Number) attributes are not used for comparison, but differences between these values will be displayed with an orange background.
[0290] ●Users can hide / unhide this details view by clicking on the "Auto Hide" pinned button in the tool. Once it is hidden, the tool will appear as "DETAILS" with the auto-hide button in the top right corner.
[0291] The page footer displays the following for the object selected in the Object Hierarchy view:
[0292] ■ A count of total records in both the source and target databases.
[0293] ■ Show / display the count of records with any data filters applied.
[0294] ■The count of records selected and merged.
[0295] The footer also contains the following controls:
[0296] ●SHOWDEPENDENCIES
[0297] ●SAVE TO DATABASE
[0298] The SHOW DEPENDENCIES control allows the user to view a list of dependency items for merging data from the source database to the target database for the selected data node. If there are any dependencies for the selected data to be saved to the target database, all such dependencies will be listed by pressing this button, for example, the product code will have dependencies on table details, groups and sections. There will be no dependencies for leaf nodes; for this case, only the selected records are displayed without any dependencies. When the user clicks the SHOW DEPENDENCIES button, a pop-up window with a tree structure hierarchy of dependent objects applicable to the selected data will be displayed. The footer displays a count of the number of records to be merged and selected for displaying dependencies. The Close button is used to close the Dependencies window and continue the merge.
[0299] The SAVE TO DATABASE control saves the merged data to the target database.
[0300] The header includes the following options:
[0301] ●Help: This option allows the user to access a "detailed user guide" on how to use the SDB Merge Tool.
[0302] ●About: Detailed version information of the "SDB Merge Tool".
[0303] ●Logout: Option to exit the SDB Merge Tool once the user completes merging the data from the source database to the target database.
[0304] When the user clicks on the Excel Report button, the data of the data nodes currently displayed in both grids will be exported to an Excel file and saved in the export folder. The data in Excel is arranged in such a way that both the source and target data along with the attribute names are placed side by side for better understanding. The user can filter a specific set of records in Excel at any point in time to see the exact content to be merged. Following is an outline of the Excel Report features:
[0305] ●When the user clicks EXCEL REPORT, a message will be displayed asking for confirmation to continue the export. When the user clicks "Yes", a progress bar will be displayed.
[0306] ●After the export is completed, a completion dialog will be displayed with a button to download the file. When the user clicks on "Download", the generated Excel file will be downloaded in the browser specific download folder path.
[0307] ●Even if the user does not download the Excel file, the generated Excel file will be present in the "Exports" folder available within the hosted merge tool physical path.
[0308] ● Regardless of the data filters selected, all data in both the source and target databases will be written to the Excel file.
[0309] In the CMS module for Component Management, a new pop-up window will be displayed
[0310] Used to select a class hierarchy. Only data related to the selected class hierarchy is exported to the Excel workbook.
[0311] ●For all data nodes for which the "Save Direct Children" checkbox is selected while saving data to the target database, Excel Report will export its child node data along with the parent data in the Excel report workbook, for example, when exporting product rules: the product rules along with the product rule details, keywords and layout will also be exported at one time.
[0312] The Merge Tool export process is a highly resource intensive job; based on the number of records in the selected database and the available system resources, it is recommended not to run multiple Excel export jobs simultaneously.
[0313] The following is an example process of how to use Excel reports in a merge workflow.
[0314] 1. When the user wants to perform a merge operation on a data node that contains a large amount of data, the user needs to first generate an Excel report for the data node using the "Excel Report" option.
[0315] 2. On the generated Excel report, apply filters for Source Records Only and Distinct Records Only.
[0316] 3. Check the data that the user wants to merge into his (customer) database.
[0317] 4. Select and perform a merge on these records.
[0318] 5. Click the "SAVE TO DATABASE" button to save the selected records to the target database.
[0319] 6. After merging the identified data, regenerate the Excel report again and verify that the required changes have been saved to the target database.
[0320] For few screens in SDB Merge Tool, Delete and Replace functionality will be enabled, for example, if user wants to merge Specification Item / Commodity Code details to merge data from source database to target database, then the data in target database needs to be deleted first and then replaced with the entire source data to avoid duplication and inconsistency in the data. For all these cases, this option will be enabled. Delete and Replace is applicable for following data nodes:
[0321] a. Commodity Code Details
[0322] b. Specification Items
[0323] c. Specification Header Geometrics
[0324] d. Specification Header Details
[0325] Clicking the "Save to Database" button will display the related parent hierarchy and save the selected records to the target database. This button will be enabled once the user merges data in the data grid from the source to the target. Features include:
[0326] ■When the user clicks on the Save to Database button, a popup window will be displayed with a tree structure hierarchy of dependent objects for merging and unique values specific to each object displayed along with check boxes at the left corner of each row for selection.
[0327] ■ The count on the footer specifies the number of records that are shown as selected to be merged and selected for saving.
[0328] ■ The notes shown below specify all mandatory dependencies to be checked after the merge is performed and, where applicable, show recommendations for a complete data view of other items that need to be merged.
[0329] ■The "Cancel" button at the bottom right is used to close the save window.
[0330] ■The "Save" button at the bottom right corner helps in saving the selected merged records in the target database.
[0331] ■ The Merge Tool honors the Control Status value defined on the target database. If the Control Status is not 1, the records in the target database are not edited / modified.
[0332] ●When the user merges data in the data grid, the Show Dependency button will be enabled
[0333] button and the Save to Database button.
[0334] When the user clicks to select to save the records into the target database (save only direct children of source data) using the checkbox, the merge tool will automatically save the product code along with all the child records of the corresponding product code, i.e., product code details, ID, tag number, product layout, product geometry information, at one go. This feature will be applicable only to "source only" records. For other cases, the user needs to check and merge the required data by navigating to the corresponding screen.
[0335] Sorting functions are provided on all available columns in source and target grids of data comparison view. If user applies sorting function on any column in source or target grid, it will be applied on both grids to ensure that grid rows will be synchronized and comparable with each other. The default sorting order is based on the order of Same, Source Only, Different, Target Only. When user clicks on a column header, data will be sorted in ascending order (sorted column will be displayed with an up arrow adjacent to the header column name). When user clicks on the same column header again, data will be sorted in descending order (sorted column will be displayed with a down arrow adjacent to the header column name). User can CTRL+click on multiple columns for sorting data in the order of column selection. (Sort order will be displayed as a number adjacent to the column header name). User can also sort in ascending order for one column and descending order for multiple columns. Numeric columns will be sorted in numerical ascending or descending order. All remaining string columns will be sorted in alphabetical ascending or descending order. When the user switches from the source grid to the destination grid to sort the columns, all the previous sorting applied on both the grids will be disabled as this functionality applies to both the grids.
[0336] A filtering feature is provided to allow the user to filter the desired column values based on a given filter condition. When the user clicks on the filter button near the column header name, a pop-up window with the column name header will be displayed. The value to be searched needs to be entered in the text field and then the "FILTER" button is clicked to apply the filter. The applied filter will be applied to both the source grid and the target grid and the data will be displayed as per the applied filter. The filter can be applied to two columns using the "AND" condition, for example, specifying two conditions to be considered and then applying the filter. In order to consider any one of the many defined filter conditions, the "OR" condition can be used.
[0337] The search criteria need to be selected according to the user's requirements. For example, the following is an outline of filtering using the StringColumns Filter:
[0338] ■If the user knows the substring of data to filter, the "Contains" search condition can be used.
[0339] ■When the user wants to filter the column values that do not have the specified substring in the column value, it is necessary to select "Does not Contain".
[0340] ■When the user wants to accurately filter the specified column value, it is necessary to select "Is equal to".
[0341] ■When the user wants to accurately not filter the specified column value, it is necessary to select "Is not equal to".
[0342] ■When applying the filter to column values that start with a specified input, you need to select "Starts with".
[0343] ■When applying a filter to a column value that does not begin with a specified input, you need to select "Does not start with".
[0344] ■When applying a filter to a column value that ends with a specified input, you need to select "Ends with".
[0345] ■When applying a filter to a column value that does not end with a specified input, you need to select "Does not end with".
[0346] ■When applying a filter to a column value that has empty values, you need to select "Is empty".
[0347] ■When applying a filter to a column value that has non-empty values, you need to select "Is not empty".
[0348] The following is an overview of filtering using the Numeric Column Filter:
[0349] ■When applying a filter to a column value that has blank values, you need to select "Is blank".
[0350] ■When applying a filter to a column value that has non-blank values, you need to select "Is notblank".
[0351] ■When the user wants to accurately filter the specified numeric column value, it is necessary to select "Is equal to".
[0352] ■When the user wants to not filter the specified numeric column value, he needs to select "Is not equal to".
[0353] ■ When applying a filter to a column value that has a value greater than some value, you need to select "Is greater than".
[0354] ■ When applying a filter to a column value that is greater than or equal to some value, you need to select "Is greater than or equal".
[0355] ■ When applying a filter to a column value that has less than some value, you need to select "Is less than".
[0356] ■ When applying a filter to a column value that is less than or equal to some value, you need to select "Is less than or equal".
[0357] Merge Workflow
[0358] This module implements the following merge steps:
[0359] 1) The user selects source only and / or distinct records as needed.
[0360] 2) The tool merges the selected records into the target grid of the merge UI.
[0361] 3) The tool displays the dependencies of the selected merged record.
[0362] 4) The tool saves the selected merged records to the target database.
[0363] Administration
[0364] This module covers the following management related objects and the merging of corresponding child nodes:
[0365] Language
[0366] ■Standard
[0367] ■Subject
[0368] ■Unit related objects (unit system, unit set, unit group, unit type and unit to unit)
[0369] Interface
[0370] ■Interface related units
[0371] ■Parameters
[0372] ■Interface settings
[0373] ■Project / Project Rule Defaults
[0374] The user should traverse all data nodes under each object to select the required rows and merge them to the target. The user only needs to verify and select the required data for the merge process.
[0375] The Document Management module covers the following document management related objects and the merging of corresponding sub-nodes:
[0376] ■Document
[0377] ■Tool version management
[0378] ■Symbol library management
[0379] When user merges "Source Only" documents, then document files (Symbol DLL) will be automatically merged as additional dependencies. To merge child data of "Source Only" records, make sure to select the "Save Source Only Child Dependencies" checkbox in the "Save" window. When user merges data on commodity code level without merging applicable documents first, then documents and only dependent parent data like PDB Documents, Symbol Libraries and Symbols will be merged, while other additional dependencies like document files, PDB Document Views will not be merged automatically. User needs to merge these objects manually in order to get symbol DLL and gif files when exporting commodity codes using SRD Transfer Job screen.
[0380] The Feature Management module allows the user to merge feature groups and corresponding child nodes as part of that object. The user must verify and merge the required feature groups, features, and feature values separately at each level where applicable. The merging of additional child dependencies is not applicable to these data nodes.
[0381] The Table Management module covers the merging of the following table management related objects and corresponding child nodes:
[0382] ● Table Type (for detailed information). This node is used to merge tables and corresponding table details. There are three types of table types under this module (commodity code table, interface table, and specification table).
[0383] ● Table Type (All) - Table Properties. This node is used to merge tables and the corresponding table attributes used to create geometric information. Since there is a large amount of data under the table management module, it is recommended to use the Excel report function to determine the required data to be merged.
[0384] The geometry information management module covers the merging of the following geometry information management related objects and their corresponding child nodes:
[0385] ●All types of geometry information tables. This node is used to merge all geometry information related data (commodity geometry information, filter geometry information, other geometry information, other special geometry information, graded geometry information, standard geometry information and wall thickness geometry information).
[0386] ● Nominal Sizes. This node is used to incorporate a table of nominal sizes used in the specification.
[0387] ●Outer Diameter. This node is used to merge the OuterDiameter table.
[0388] ● Branch. This node is used to merge the branch table used in the specification.
[0389] ●.Schedules: This node is used to merge the outer diameter table.
[0390] ●Nominal Reducer: This node is used to merge nominal reducer tables.
[0391] ●Metric / English Equivalence: This node is used to merge the English into the Metric Equivalence table.
[0392] Merging of 'Source Only' geometry information tables will automatically merge the corresponding table details / properties if the 'Save direct children for sourceonly data' checkbox is selected. For 'Target Only' records, the user needs to verify whether the data will create any copies in the target database and take appropriate action.
[0393] The Commodity / Ident Management module covers the merging of the following Commodity / Ident Management related objects and their corresponding child nodes:
[0394] ● Product Rules. This node is used to merge product rules and their sub-item details.
[0395] ● Commodity Group / Part / Commodity Code. This node is used to merge commodity groups, parts, commodity codes and corresponding sub-item details in sequential order. Delete and replace functions are implemented for commodity code details, because commodity codes are completely dependent on commodity code details. And partial merging of commodity code details will result in incorrect data in the customer database.
[0396] Implement the delete and replace functionality so that even if the user selects a single record to merge, all data under that node will automatically be merged into the customer database.
[0397] ●Object Parameters. This node is used to merge object parameters and their child details.
[0398] ●Part Object Parameters: This node is used to merge object parameters linked to each part.
[0399] ●Parts with table groups and parts with table details. These nodes are used to merge table groups and table details linked to parts.
[0400] ● Parts with SP3D short codes. This node is used to merge S3D short codes assigned at the part level.
[0401] The Geometry Rules module is used to merge geometry rules and corresponding children details. Merging of Source Only geometry rules will automatically merge the corresponding rule definitions if the Save direct children for source only data checkbox is selected. For target only / different records, the user needs to validate the data and take appropriate action.
[0402] The Specification module includes a merger of the following specification-related objects and corresponding child nodes:
[0403] ●Short Code Management. This node is used to merge SRD short codes and corresponding sub-item details.
[0404] ● Description. This node is used to merge specification descriptions.
[0405] ● Specification Rules. This node is used to merge specification rules and corresponding sub-item details.
[0406] ● Specification Type. This node is used to merge the specification type and the corresponding sub-item details.
[0407] ● Functional Specification Settings. This node is used to merge the functional specification settings and the corresponding sub-item details.
[0408] ● Specifications. This node is used to merge all specification related data and corresponding sub-item details. Implement delete and replace functionality for Specification Header Geometry, Specification Details, and Specification Items, as partial merges of data related to these nodes will result in incorrect data in the customer database. Implement delete and replace functionality so that even if the user selects a single record to merge, all data under that node will automatically be merged to the customer database.
[0409] The Smart 3D / CADWorx Integration module covers the merging of the following Smart 3D / CADWorx Integration related objects and corresponding sub-nodes:
[0410] ●Configuration. This node is used to merge all Smart3D / CADWorx configuration related data (data tables, Smart 3D properties, transfer types, retrieval sources, programs, data table configurations, templates, data table mappings, and property mappings) and the corresponding sub-item details.
[0411] ●Transfer Jobs. This node is used to merge all Smart3D / CADWorx transfer job related data (general configuration, destination, directory structure and transfer jobs) and corresponding sub-item details.
[0412] The SPIso Integration module covers the merging of the following SPIso Integration related objects and corresponding sub-nodes:
[0413] ●Master Data. This node is used to consolidate all SPIso master data and corresponding sub-item details required to configure SPIso integration.
[0414] ●SPIso SKEY Mapping: This node is used to merge the SKEY mapping and corresponding sub-item records required to configure SPIso integration.
[0415] ● Export. This node is used to merge SPIso export related data and corresponding sub-item records. The CMS (Component Management System) module covers the merging of the following CMS related objects and corresponding sub-nodes:
[0416] ● Manage Class System: This node is used to merge CMS class related data and corresponding sub-item details.
[0417] ●Component Manager: This node is used to merge CMS component related data and corresponding sub-item details.
[0418] All merge operations under CMS module should be performed using Project SDB and English language only. Before merging CMS component data, unique key details need to be set on the source database for the existing class attributes.
[0419] Fig.29 is an annotated screenshot showing an example data comparison window for S3D information according to an exemplary embodiment. The main portion of the window displays identical records (not highlighted), source-only or target-only records (highlighted in green), and different records (highlighted in orange) in order from top to bottom. On the right hand side of the screen is a window that displays the differences for the selected row (in this case, the second row in the green highlighted portion). The filter buttons are identified.
[0420] Fig.30 is a screenshot showing an example data comparison window for transferring job information according to an exemplary embodiment. Fig.29 As shown, the main part of the screen displays identical records (not highlighted), source-only or target-only records (highlighted in green), and different records (highlighted in orange) in order from top to bottom. On the right-hand side of the screen is a window that displays the differences for the selected line (in this case, the second line in the green highlighted section).
[0421] Fig.31 is a screenshot showing an example data comparison window for illustrating information according to an exemplary embodiment. Here, the "same" filter is turned off, so that only source only, target only, and different records are displayed.
[0422] Fig.32 is a screenshot illustrating an example data comparison window in which all displayed records are identical in both databases in accordance with an exemplary embodiment.
[0423] Fig.33 is a screenshot showing four active SDB Merge Tool windows according to an exemplary embodiment.
[0424] Fig.34 is a screenshot showing an example object dependency hierarchy window according to an exemplary embodiment. From this window, a user can select an object and merge it into a target database including all mandatory dependencies. A user can expand an object to view all its mandatory dependencies.
[0425] Fig.35 is a screenshot showing an Export to Excel window in a first format according to an exemplary embodiment, wherein records are sorted by Same, Source Only, Target Only, and Different.
[0426] Fig.36 is a screenshot showing an "Export to Excel" window in a second format according to an exemplary embodiment, with individual differences highlighted. Here, for example, one particular object is listed as "Wrought" in the source database and as "Forged" in the target database. This difference is highlighted in orange. Source-only and target-only records are highlighted in green.
[0427] Miscellaneous
[0428] It should be noted that the headings used above are for convenience and are not to be construed as limiting the invention in any way.
[0429] It should be noted that arrows may be used in the accompanying drawings to represent communications, transmissions, or other activities involving two or more entities. Double-ended arrows generally indicate that activities can occur in two directions (e.g., a command / request in one direction and a corresponding reply in the other direction, or a peer-to-peer communication initiated by either entity), but in some cases, activities may not necessarily occur in both directions. Single-ended arrows generally indicate only or primarily indicate activities in one direction, although it should be noted that in some cases, such directional activities may actually involve activities in two directions (e.g., a message from a sender to a receiver and an acknowledgment returned from the receiver to the sender, or establishing a connection before a transmission and terminating the connection after the transmission). Therefore, the types of arrows used to represent specific activities in a particular figure are exemplary and should not be considered restrictive.
[0430] It should be noted that logic flow can be described in this article to illustrate various aspects of the present invention, and should not be construed as limiting the present invention to any specific logic flow or logic implementation. The described logic can be divided into different logic blocks (e.g., programs, modules, functions or subroutines) without changing the overall result or otherwise departing from the true scope of the present invention. Typically, logic elements can be added, modified, omitted, performed in different orders or implemented using different logic structures (e.g., logic gates, loop primitives, conditional logic and other logic structures) without changing the overall result or otherwise departing from the true scope of the present invention.
[0431] The present invention may be implemented in many different forms, including, but not limited to, computer program logic used with a processor (e.g., a microprocessor, a microcontroller, a digital signal processor, or a general purpose computer), programmable logic used with a programmable logic device (e.g., a field programmable gate array (FPGA) or other PLD), discrete components, integrated circuits (e.g., an application specific integrated circuit (ASIC)), or any other device including any combination thereof. Computer program logic that implements some or all of the described functions is typically implemented as a set of computer program instructions that are converted into a computer executable form, stored in a computer readable medium, and executed by a microprocessor under the control of an operating system. Hardware-based logic that implements some or all of the described functions may be implemented using one or more appropriately configured FPGAs.
[0432] The computer program logic that implements all or part of the functions previously described herein can be implemented in various forms, including but not limited to, source code form, computer executable form, and various intermediate forms (e.g., forms generated by assemblers, compilers, linkers, or locators). The source code may include a series of computer program instructions implemented in any of various programming languages (e.g., object code, assembly language, or high-level languages such as Fortran, C, C++, JAVA, or HTML) for use with various operating systems or operating environments. The source code may define and use various data structures and communication messages. The source code may be in a computer executable form (e.g., via an interpreter), or the source code may be converted (e.g., via a translator, assembler, or compiler) to a computer executable form.
[0433] The computer program logic that implements all or part of the functionality previously described herein may be executed at different times on a single processor (e.g., concurrently), or may be executed at the same or different times on multiple processors, and may run under a single operating system process / thread or different operating system processes / threads. Thus, the term "computer process" generally refers to the execution of a set of computer program instructions, regardless of whether different computer processes are executed on the same or different processors, and regardless of whether different computer processes are running under the same operating system process / thread or different operating system processes / threads.
[0434] A computer program may be fixed in any form (e.g., source code form, computer executable form, or intermediate form) permanently or temporarily in a tangible storage medium, such as a semiconductor memory device (e.g., RAM, ROM, PROM, EEPROM, or flash programmable RAM), a magnetic memory device (e.g., a magnetic disk or fixed disk), an optical memory device (e.g., a CD-ROM), a PC card (e.g., a PCMCIA card), or other memory device. A computer program may be fixed in any form in a signal that can be transmitted to a computer using any of a variety of communication technologies, including but not limited to analog, digital, optical, wireless (e.g., Bluetooth), networking, and internet technologies. A computer program may be distributed in any form as a removable storage medium with accompanying printed or electronic documentation (e.g., shrink-wrapped software), preloaded with a computer system (e.g., on a system ROM or fixed disk), or distributed from a server or electronic bulletin board over a communication system (e.g., the Internet or the World Wide Web).
[0435] Hardware logic that implements all or part of the functionality previously described herein (including programmable logic used with programmable logic devices) may be designed using traditional manual methods, or may be electronically designed, captured, simulated, or recorded using various tools such as computer-aided design (CAD), hardware description languages (e.g., VHDL or AHDL), or PLD programming languages (e.g., PALASM, ABEL, or CUPL).
[0436] Programmable logic may be permanently or temporarily fixed in a tangible storage medium, such as a semiconductor memory device (e.g., RAM, ROM, PROM, EEPROM, or flash programmable RAM), a magnetic memory device (e.g., a magnetic disk or fixed disk), an optical memory device (e.g., a CD-ROM), or other memory device. Programmable logic may be fixed in a signal that may be transmitted to a computer using any of a variety of communication technologies, including but not limited to analog, digital, optical, wireless (e.g., Bluetooth), networking, and internet technologies. Computer logic may be distributed as a removable storage medium with accompanying printed or electronic documentation (e.g., shrink-wrapped software), preloaded with a computer system (e.g., on a system ROM or fixed disk), or distributed from a server or electronic bulletin board via a communication system (e.g., the Internet or the World Wide Web). Of course, some embodiments of the present invention may be implemented as a combination of both software (e.g., a computer program product) and hardware. Other embodiments of the present invention are implemented as either entirely hardware or entirely software.
[0437] It is important to note that embodiments of the present invention may employ conventional components (e.g., conventional computers (e.g., off-the-shelf PCs, mainframes, microprocessors)), conventional programmable logic devices (e.g., off-the-shelf FPGAs or PLDs), or conventional hardware components (e.g., off-the-shelf ASICs or discrete hardware components) that, when programmed or configured to perform the non-conventional methods described herein, produce non-conventional devices or systems. Thus, the invention described herein is not conventional because, even when conventional components are used to implement embodiments, the resulting devices and systems (e.g., the SDB merge tool described herein) are necessarily non-conventional because, absent specific programming or configuration, conventional components do not inherently perform the described non-conventional methods.
[0438] Without departing from the true scope of the invention, the present invention may be implemented in other specific forms, and based on the teachings herein, a person skilled in the art will understand many variations and modifications. Any reference to the "present invention" is intended to represent an exemplary embodiment of the present invention, and should not be interpreted as referring to all embodiments of the present invention, unless the context otherwise requires. The described embodiments are considered to be illustrative and non-restrictive in all respects.< / bodefinitions>
Claims
1. A method for merging objects from a source database into a target database, the method comprising the following steps: obtaining a unique key attribute of the object according to a configuration file, wherein the object is associated with data stored in a plurality of relational database tables in the source database; The source database is queried using the unique key attribute to obtain a primary key value of the object from the first relational database table, and after querying the source database to obtain the primary key value, the method further comprises the following steps: identifying a parent object associated with the object, the parent object being associated with a second relational database table; Obtaining a unique key of the identified parent object according to the configuration file; querying the source database using the obtained unique key of the parent object to obtain the parent unique key value of the parent object from the second relational database table; querying the target database using the obtained parent unique key value to determine whether the target database includes an existing parent object record having the parent unique key value; When the target database does not include an existing parent object record having the parent unique key value, adding a parent object record including the parent unique key value to the target database, and then adding an object record including the first primary key value and a reference to the parent unique key value in the added parent object record to the target database; and When the target database includes an existing parent object record having the parent unique key value, an object record including the first primary key value and a reference to the parent unique key value in the existing parent object record is added to the target database.
2. The method according to claim 1, wherein: The step of using the obtained unique key of the parent object to query the source database to obtain the parent unique key value of the parent object from the second relational database table includes: The first relational database table and the second relational database table are connected.
3. The method according to claim 1, wherein: The step of adding the parent object record including the parent unique key value to the target database comprises: An identifier is assigned to the parent unique key value, wherein the identifier is unique within the target database and is assigned independently of a corresponding identifier of the parent unique key value in the source database.
4. The method according to claim 3, wherein: The reference to the parent unique key value includes a unique identifier assigned to the parent unique key value.
5. The method according to claim 1, wherein: The step of adding the object record to the target database comprises: An identifier is assigned to the first primary key value, wherein the identifier is unique within the target database and is assigned independently of a corresponding identifier for the primary key value in the source database.
6. The method according to claim 5, wherein: When the parent unique key value exists in a parent object record in the target database, the reference to the parent unique key value includes an identifier associated with the existing parent unique key value.
7. The method according to claim 1, further comprising the steps of: The configuration file is maintained, the configuration file describing the data stored in the plurality of relational database tables, the configuration file including the relationships between the plurality of relational database tables.
8. A database system for merging objects from a source database into a target database, the database system comprising: Multiple relational database tables; as well as A merge tool having program code, which, when executed by at least one processor of the database system, causes the database system to perform a computer process, the computer process comprising the following steps: obtaining a unique key attribute of the object according to a configuration file, wherein the object is associated with data stored in a plurality of relational database tables in the source database; The source database is queried using the unique key attribute to obtain a primary key value of the object from a first relational database table, and after querying the source database to obtain the primary key value, the computer processing further comprises the following steps: identifying a parent object associated with the object, the parent object being associated with a second relational database table; Obtaining a unique key of the identified parent object according to the configuration file; Using the obtained unique key of the parent object, querying the source database to obtain the parent unique key value of the parent object from the second relational database table; querying the target database using the obtained parent unique key value to determine whether the target database includes an existing parent object record having the parent unique key value; When the target database does not include an existing parent object record having the parent unique key value, adding a parent object record including the parent unique key value to the target database, and then adding an object record including the first primary key value and a reference to the parent unique key value in the added parent object record to the target database; and When the target database includes an existing parent object record having the parent unique key value, an object record including the first primary key value and a reference to the parent unique key value in the existing parent object record is added to the target database.
9. The database system according to claim 8, wherein: The step of using the obtained unique key of the parent object to query the source database to obtain the parent unique key value of the parent object from the second relational database table includes: The first relational database table and the second relational database table are connected.
10. The database system according to claim 8, wherein: The step of adding the parent object record including the parent unique key value to the target database comprises: An identifier is assigned to the parent unique key value, wherein the identifier is unique within the target database and is assigned independently of a corresponding identifier of the parent unique key value in the source database.
11. The database system according to claim 10, wherein: The reference to the parent unique key value includes a unique identifier assigned to the parent unique key value.
12. The database system according to claim 8, wherein: The step of adding the object record to the target database comprises: An identifier is assigned to the first primary key value, wherein the identifier is unique within the target database and is assigned independently of a corresponding identifier for the primary key value in the source database.
13. The database system according to claim 12, wherein: When the parent unique key value exists in a parent object record in the target database, the reference to the parent unique key value includes an identifier associated with the existing parent unique key value.
14. The database system according to claim 8, further comprising: The configuration file is maintained, the configuration file describing the data stored in the plurality of relational database tables, the configuration file including the relationships between the plurality of relational database tables.
15. A computer program product for merging objects from a source database into a target database, the computer program product comprising a tangible, non-transitory computer-readable medium, the computer-readable medium containing program code, which, when executed by at least one processor of a database system, causes the database system to perform a computer process, the computer process comprising the following steps: obtaining a unique key attribute of the object according to a configuration file, wherein the object is associated with data stored in a plurality of relational database tables in the source database; The source database is queried using the unique key attribute to obtain a primary key value of the object from a first relational database table, and after querying the source database to obtain the primary key value, the computer processing further comprises the following steps: identifying a parent object associated with the object, the parent object being associated with a second relational database table; Obtaining a unique key of the identified parent object according to the configuration file; Using the obtained unique key of the parent object, querying the source database to obtain the parent unique key value of the parent object from the second relational database table; querying the target database using the obtained parent unique key value to determine whether the target database includes an existing parent object record having the parent unique key value; When the target database does not include an existing parent object record having the parent unique key value, adding a parent object record including the parent unique key value to the target database, and then adding an object record including the first primary key value and a reference to the parent unique key value in the added parent object record to the target database; and When the target database includes an existing parent object record having the parent unique key value, an object record including the first primary key value and a reference to the parent unique key value in the existing parent object record is added to the target database.
16. The computer program product of claim 15, wherein: The step of using the obtained unique key of the parent object to query the source database to obtain the parent unique key value of the parent object from the second relational database table includes: The first relational database table and the second relational database table are connected.
17. The computer program product of claim 15, wherein: The step of adding the parent object record including the parent unique key value to the target database comprises: An identifier is assigned to the parent unique key value, wherein the identifier is unique within the target database and is assigned independently of a corresponding identifier of the parent unique key value in the source database.
18. The computer program product of claim 17, wherein: The reference to the parent unique key value includes a unique identifier assigned to the parent unique key value.
19. The computer program product of claim 15, wherein: The step of adding the object record to the target database comprises: An identifier is assigned to the first primary key value, wherein the identifier is unique within the target database and is assigned independently of a corresponding identifier for the primary key value in the source database.
20. The computer program product of claim 19, wherein: When the parent unique key value exists in a parent object record in the target database, the reference to the parent unique key value includes an identifier associated with the existing parent unique key value.
21. The computer program product of claim 15, further comprising: The configuration file is maintained, the configuration file describing the data stored in the plurality of relational database tables, the configuration file including the relationships between the plurality of relational database tables.
Citation Information
Patent Citations
System and method for comparing and selectively merging database records
US20190384847A1
Method and a system for merging data into a database table
CN104462169A
Merging method for database
CN106033436A
