Applying the changes in the target database system

Abstract

In an approach for dynamically selecting, by one or more processors, an application algorithm to be used for each change in a target database system, the processor provides at least two application algorithms for applying changes to a table in the target database system. For each application algorithm of the at least two application algorithms, the processor determines a performance behavior of each application algorithm versus a size of the change to be applied to the table by the respective application algorithm. The processor receives a data modification request to apply a change to a table. The processor determines a size of the change to the table. The processor selects one of the at least two application algorithms that provides optimal performance for the size based on the performance behavior of each application algorithm. The processor applies the change to the table using the selected application algorithm that provides optimal performance for the size.

Description

[Technical Field]

[0001] The present invention relates to the field of database systems, and more particularly to providing a method for dynamically selecting application algorithms used to apply changes in a target database system. [Background technology]

[0002] Replication is the process of maintaining a defined set of data in multiple locations. It may involve copying specified changes from one source location to a target location and synchronizing the data in both locations. The source and target may be logical servers on the same machine or on different machines across a distributed network. Several approaches exist for moving data from one system to another; however, these approaches may require further refinement. Summary of the Invention

[0003] Aspects of embodiments of the present invention disclose a computer-implemented method, a computer program product, and a computer system for dynamically selecting an application algorithm used to apply changes in a target database system. Embodiments of the present invention may be freely combined with each other if they are not mutually exclusive.

[0004] The processor provides multiple application algorithms for applying changes in a target database system. For each of the provided application algorithms, the processor determines the performance behavior of the application algorithm for different sizes of changes to be applied by the application algorithm to a table in the target database system. The processor receives a data change request to apply a change to a table. The processor determines the size of the requested change to the table. The processor uses the determined performance behavior to select one of the application algorithms that provides optimal performance for the determined size. The processor applies the requested change to the table using the selected application algorithm. [Brief explanation of the drawings]

[0005] [Figure 1] 1 illustrates a data processing system according to an embodiment of the present invention; [Figure 2] 1 is a flowchart of a method for applying changes in a target database system according to an embodiment of the present invention. [Figure 3] 1 is a flowchart of a method for applying changes in a target database system according to an embodiment of the present invention. [Figure 4] 1 is a flowchart of a method for applying changes in a target database system according to an embodiment of the present invention. [Figure 5] 1 is a flowchart of a method for applying changes in a target database system according to an embodiment of the present invention. [Figure 6A] 1 is a flowchart of a method for determining performance behavior of an application algorithm according to an embodiment of the present invention. [Figure 6B] 1 is a flowchart of a method for determining performance behavior of an application algorithm according to an embodiment of the present invention. [Figure 6C]4 is a curve illustrating the performance behavior of an application algorithm according to an embodiment of the present invention. [Figure 7] 1 depicts a computerized system suitable for performing one or more method steps according to embodiments of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0006] The description of various embodiments of the present invention is presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. It will be apparent to those skilled in the art that many modifications and variations are possible without departing from the scope of the described embodiments. The terms used herein have been selected to best explain the principles of the embodiments, practical applications or technical improvements to technology found in the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

[0007] The target database system may be part of a data analysis system. The data analysis system includes a target database system and a source database system. The data analysis system may be, for example, a data warehouse system or a master data management system. The data analysis system may enable data warehousing, master data management, or other technologies using a source database system and a target database system, and the target database system includes a target database configured to receive / configure a copy of the contents of the corresponding source database of the source database system. The source database system may be connected to the target database system via a connection. The connection may be, for example, a TCP / IP connection or other connection that enables communication of data between the source database system and the target database system. The source database system may be, for example, a transactional engine, and the target database system may be an analytical engine. For example, the source database system may be an online transaction processing (OLTP) system, and the target database system may be an online analytical processing (OLAP) system. The source database system may constitute a source dataset, and the target database system may constitute a target dataset. The source dataset may be part of the source database, and the target dataset may be part of the target database. The source dataset and the target dataset may be stored in the same format or different formats. The formats may differ in encryption, compression, row-oriented versus column-oriented storage, etc. For example, the source dataset may be stored in a row-oriented format and the target dataset may be stored in a column-oriented format (i.e., the target dataset may be stored column-wise rather than row-wise). The contents of the source dataset may be modified by one or more database transactions.

[0008] A data analysis system may be configured to replicate changes that occur in a source table of a source database system to a target database system, thereby applying the changes on target tables in the target database system that correspond to the source tables. Applying changes may include, for example, inserting one or more records, updating one or more records, or deleting one or more records in one or more tables of the target database system, or a combination thereof. A data record or table record is a collection of related data items, such as a particular user's name, date of birth, or class. A record represents an entity, which refers to a user, object, or concept whose information is stored in the record. To this end, multiple application algorithms (sometimes referred to as update strategies) may be provided, each specifying a sequence of replication operations to be performed to apply changes to the target database system. Application algorithms may include, for example, incremental load-based algorithms and bulk load-based algorithms. An incremental load-based algorithm may, for example, require that each change recorded in a log record be applied individually in the target database system. An incremental load-based algorithm may be particularly advantageous for small datasets because the overhead for large chunks may be high. A bulk-load-based application algorithm, for example, may require that changes recorded in log records be staged in batches. These batches can then be applied to the target database system via a bulk-load interface. Bulk-load-based application algorithms may be advantageously used for large data sets. However, the overhead of setting up a bulk load may be too high to justify spending on small chunks consisting of only a few rows.

[0009] Therefore, depending on the changes applied to the target database system, the application algorithm may have different performance. However, accurately and systematically selecting the appropriate algorithm may be a non-trivial task. The present invention may solve this problem by providing an optimal and efficient method for dynamically selecting the application algorithm to use for each change. This method may be time-efficient because it can save additional time that would be required by an inappropriate application algorithm. This method is considered optimal because it is determined based on accurate and up-to-date performance behavior.

[0010] TIFF0007798453000001.tif142168

[0011] TIFF0007798453000002.tif50167

[0012] According to one embodiment, the method further includes repeating the steps of determining a size for each received data modification request for the table, selecting an application algorithm, and applying the modifications, thereby dynamically updating the performance behavior of the table.

[0013] According to one embodiment, the method further includes performing a performance behavior determination step for each additional table of the target database system, such that each table of the target database system is associated with a respective performance behavior, and repeating the steps of determining a size, selecting an application algorithm, and applying the changes for each received data change request for a specific table of the target database system using the performance behavior associated with the specific table. This embodiment may be advantageous because it also makes the performance behavior of the application algorithm table dependent. This may be particularly advantageous because the same application algorithm may be the most efficient algorithm for a given change size for a given table with few columns, but may be inefficient for the same change size for another table with many more columns, or the columns may have different data types.

[0014] According to one embodiment, determining the performance behavior of an application algorithm includes executing the application algorithm a predefined number N of times to each apply a data change to a table, each applied data change having a size; evaluating, for each data change, at least one performance parameter indicative of the performance of the execution of the application algorithm; and providing a data structure of N data points representing the performance behavior, each data point indicating the evaluated performance parameter and an associated size of the data change. This embodiment may be advantageous because, upon initial configuration of a data analysis system, no measurements may yet be available. This embodiment may enable an initial execution of the application algorithm that provides initial measurements that may later be refined. In one example, the initial execution of the application algorithm may be a dummy execution using dummy data; for example, 1,000 rows may be inserted into a table and execution time may be measured. The changes to these 1,000 rows may be rolled back without being committed. In another example, the execution of the application algorithm may be triggered by N received change requests. The application algorithm may be selected from among the predefined algorithms randomly, by round robin, or some other scheme. This is done until enough measurement points N are available.

[0015] According to one embodiment, the number N is less than a configurable maximum number of runs (e.g., 3). The method further includes constructing new data points in the data structure using interpolation of the N data points. For example, two (i.e., N=2) INSERTs may be performed with each of the application algorithms for inserting a certain number of rows. The number of rows in the two INSERTs may be different, with greater variability, such as 100 rows and 700 rows (rather than 100 rows and 101 rows). Performance parameters may be evaluated for each of the two INSERTs. This can be done, for example, by defining a first baseline in the form of a linear curve, followed by extrapolation. Splines can be used to approximate the curve or simple linear interpolation.

[0016] According to one embodiment, the performance parameter is one of execution time and memory usage.

[0017] According to one embodiment, the size of the change includes the number of records inserted, the number of records deleted, or the number of records updated, or a combination thereof.

[0018] According to one embodiment, selecting an application algorithm includes determining whether the performance of two application algorithms for a determined size is similar and, if so, selecting one of the two application algorithms. Two application algorithms may have similar performance at a crossover point between their performance behaviors. This crossover point may have a very important characteristic: it is the break-even point in performance. The performance of algorithm A or algorithm B when processing "n" rows is identical. That is, it doesn't matter which algorithm you choose. Even if you deviate slightly from the crossover point, there won't be a significant "jump" in the performance curve. For example, if algorithm A is superior below 1000 rows and algorithm B is superior above 1000 rows, selecting algorithm B at 990 rows will still be very close to algorithm A. This has extremely useful implications for ensuring a smooth transition when switching from algorithm A to algorithm B.

[0019] According to one embodiment, the application algorithm is one of a record bulk load based application and an individual record load based application.

[0020] According to one embodiment, the method further includes providing a source table associated with a table in a source database system, the source database system and the target database system being configured to synchronize data between one another; and receiving a data change request in response to the data change being applied to the source table, thereby replicating the data change.

[0021] Implementation of embodiments of the present invention may take a variety of forms, and details of exemplary implementations are provided below with reference to the figures.

[0022] 1 is a block diagram of a data processing system (or data analysis system) 100 according to an embodiment of the present invention. The data processing system 100 may be configured to perform data synchronization between a source database system 101 and a target database system 103 using a data synchronization system 102 according to an embodiment of the present invention. The source database system 101 may be, for example, an online transaction processing (OLTP) system. The target database system 103 may be, for example, an online analytical processing (OLAP) system. Communication between the source database system 101 and the target database system 103 may be performed via, for example, a TCP / IP communication layer.

[0023] The source database system 101 includes one or more source tables 105 of a source database 106 and a transaction recovery log 107. Entries or log records in the transaction recovery log 107 describe changes to rows or records of the source table 105 in the source database system 101. FIG. 1 illustrates an example of the contents of a log record 130. The log record 130 may include a timestamp, an LRSN, and attribute changes. More specifically, a log record in the transaction recovery log 107 may include information defining, for example, (1) the table being modified, (2) the values ​​of key columns in the row being modified, (3) the old and new values ​​of all columns in the row being modified, and (4) the transaction (unit of work) that caused the change. By definition, an insert is a new data record and therefore has no old values. By definition, a delete change does not have a new data record, only an old data record. Therefore, a transaction log record for an inserted row may contain only new column values, and a transaction log record for a deleted row may contain only old column values. The transaction log record for an updated row may include the old and new values ​​of all rows and columns. The order of the log records in the transaction recovery log may reflect the order of the transaction modification operations, and the order of the transaction commit records may reflect the order in which the transactions were completed. The type of row operation in a transaction log record may be, for example, delete, insert, or update.

[0024] The data synchronization system 102 includes a log reader 104. While shown as part of the data synchronization system 102, the log reader 104 may, in another example, be part of the source database system 101. The log reader 104 may read log records from the transaction recovery log 107 and provide them to the change record classifier 120. The change record classifier 120 may classify the log records based on their changes (e.g., to determine the size of the change) so that the algorithm selection module 121 can select one of the application algorithms 108.1-108.3 based on the classification of the log records, and updates can be performed based on the selected application algorithm. The selection of an application algorithm and the application of changes using the application algorithm may be performed periodically, e.g., hourly, or automatically, as soon as a predefined amount of log records (e.g., 1,000 log records) are saved to the transaction recovery log 107, and that amount of log records may be used to define a new change request. At each iteration, only newly added log records with respect to the previously provided log records may be processed. The selected application algorithm may include, for example, a bulk load-based update strategy or one or more incremental update strategies, corresponding to bulk load-based algorithm 108.3 and incremental algorithms 108.1 and 108.2, respectively. Synchronization may be performed differently for the bulk load-based update strategy and the incremental update strategy.

[0025] The log reader 104 may be configured to perform log shipping of the transaction recovery log 107 to the target database system 103 based on the incremental update algorithm selected by the selection module 121. Shipping may be performed, for example, by sending a stream of log records formed from the log records of the transaction recovery log 107. The shipped log stream may be associated with, for example, a stream ID. The stream of log records may be, for example, a stream of merged log records. This may enable efficient processing of the log records in the target database system 103. The target database system 103 may be configured with multiple algorithms 108.1 and 108.2, each associated with a respective incremental update strategy. While FIG. 1 shows only three algorithms for illustrative purposes, the number or types of algorithms is not limited to these. The target database system 103 further includes one or more target table copies 113. The target database system includes a log streaming interface for receiving the log stream from the source database system 101. Each of algorithms 108.1 and 108.2 may be configured to receive a stream of log records via a log streaming interface. Each of algorithms 108.1 and 108.2 may buffer the received log records and consolidate the changes into batches, for example via a bulk load interface, to improve efficiency when applying the changes to table copies 113 in target database 114.

[0026] In another example, a bulk load-based (snapshot update) algorithm 108.3 may be performed between the source database system 101 and the target database system 103 based on a selected bulk load-based update strategy. The load, which may be a load of the entire table data or a load of a set of partitions of a table at a given point in time, is performed directly from the source database system 101 to the target database system 103. The data on the target database system 103 may reflect the source database system state at the time the load was performed.

[0027] Although shown as a separate component, data synchronization system 102 may, in alternative embodiments, be part of source database system 101 or part of target database system 103. In one embodiment, source database system 101 and target database system 103 may each be on the same system or on different systems within a distributed network.

[0028] FIG. 2 illustrates a table T in a target database system according to an embodiment of the present invention. g 2 is a flowchart of a method for applying changes to a source database system (T). For illustrative purposes, the method described in FIG. 2 may be implemented in the system shown in FIG. 1, but is not limited to this implementation. The method of FIG. 2 may be performed, for example, by data synchronization system 102. The method of FIG. 2 may be performed, for example, by a source database system (T). g (corresponding to the source table T) S In this case, it may be possible to apply the changes made to the target database system, thereby enabling synchronization between the source and target database systems.

[0029] To apply changes to the target database system, multiple application algorithms may be provided in step 201. For example, application algorithms App1,...App r where r is the number of changes in a table, where r is greater than or equal to 2. The application algorithms may include, for example, a single-record application algorithm and a bulk-load application algorithm. A single-record application algorithm can apply each change recorded in each log record individually. Each algorithm may apply changes in a different way, so that they can be effectively applied to other application algorithms. For example, a single-record application algorithm may apply changes to a table T g You can update only the data that has changed since the last update of the corresponding source table T S Every time a change occurs in table T g The entire record can be updated, which may provide two different single record application algorithms.

[0030] TIFF0007798453000003.tif99168

[0031] Step 203 may be performed, for example, as part of a pre-processing step (e.g., by creating a table T g The number of changes N may be selected to be as small as possible (e.g., N=2), since step 203 may be performed at runtime of the data analysis system, since it may be resource-intensive to evaluate all application algorithms for each of the N changes.

[0032] However, if the number of modifications N is not sufficient to estimate the performance of the requested modifications, the resulting data structure curv1,...curv rmay be further enhanced by adding additional points to them. This addition of additional points can be done, for example, using interpolation. The interpolation can be, for example, linear or spline interpolation. Thus, the data structure curv1,...curv r may each have N+x data points. In another example, the data structures curv1,...curv r may be processed to model their behavior using mathematical functions. Thus, step 203 involves the calculation of the application algorithms App1, ...App r A user may generate r data structures or r mathematical functions with discrete points that represent the performance behavior of the system.

[0033] In step 205, table T g A data modification request can be received to apply changes to a source table T. s In response to detecting a change in the data, a data change request may be sent to a data synchronization system, for example, data synchronization system 102 of FIG.

[0034] In response to receiving a data modification request, the size of the requested modification may be determined in step 207. The definition of size may be the same as that used to determine performance behavior. For example, the requested data modification size s t is the number of records to be inserted or the table T g This could be the number of records to be deleted from the

[0035] The determined size s t is the size s determined in step 209. t , can be used to select the application algorithm that provides the best performance compared to other application algorithms. r The performance of each of the determined sizes s tThis estimation is done by using the data structure curv1,...curv r , or using the mathematical model determined in step 203. For example, a data structure with discrete points, curv1,...curv r When using the determined size s of each data structure, t A closest point to may be identified. As a result, r closest points may be generated. Values ​​of performance parameters of the closest points may be compared, and the optimal closest point may be selected. The selected closest point may be associated with one of the application algorithms. One of the application algorithms may be the selected application algorithm of step 209.

[0036] When using a mathematical model, the determined size s t is size S t The r performance parameters can be used as arguments or inputs to each mathematical model to estimate the performance associated with the r parameter. This can result in a set of r performance parameter values ​​that can be compared to identify the optimal performance and associated application algorithm.

[0037] The requested changes are then processed in step 211 using the selected application algorithm to generate the table T g can be applied to.

[0038] FIG. 3 illustrates a table T in a target database system according to an embodiment of the present invention. g 3 is a flowchart of a method for applying changes to a source database system (T). For illustrative purposes, the method described in FIG. 3 may be implemented in the system shown in FIG. 1, but is not limited to this implementation. The method of FIG. 3 may be performed, for example, by data synchronization system 102. The method of FIG. 3 may be performed, for example, by applying changes to a source database system (T). g (corresponding to the source table T) sIn this case, it may be possible to apply the changes made to the target database system, thereby enabling synchronization between the source and target database systems.

[0039] TIFF0007798453000004.tif38168

[0040] Figure 4 is a flowchart of a method for applying changes to multiple tables in a target database system according to an embodiment of the present invention. For illustrative purposes, the method described in Figure 4 may be implemented in the system shown in Figure 1, but is not limited to this implementation. The method of Figure 4 may be performed, for example, by data synchronization system 102. The method of Figure 4 may enable changes made in, for example, multiple source tables (corresponding to multiple target tables) in a source database system to be applied to a target database system, thus enabling synchronization between the source and target database systems.

[0041] A number of application algorithms may be provided in step 401 (eg, as described in step 201) to apply changes to the target database system.

[0042] Application algorithms App1,...App r The performance behavior of each application algorithm may be determined for each table of the plurality of tables in step 403. For example, step 403 may include performing step 203 of Figure 2 for each table of the plurality of tables. This may be advantageous because it makes the performance behavior of the application algorithm also dependent on the table.

[0043] In step 405, a data modification request may be received to apply one or more modifications to one or more tables, respectively. The modifications may have different sizes because they are applied to different tables.

[0044] For each table of one or more tables, steps 407 through 411 may be performed using and applying the performance behavior of that table. Steps 407 through 411 are steps 207 through 211 in FIG.

[0045] Figure 5 is a flowchart of a method for applying changes to multiple tables in a target database system according to an embodiment of the present invention. For illustrative purposes, the method described in Figure 5 may be implemented in the system shown in Figure 1, but is not limited to this implementation. The method of Figure 5 may be performed, for example, by data synchronization system 102. The method of Figure 5 may enable changes made in, for example, multiple source tables (corresponding to multiple target tables) in a source database system to be applied to a target database system, thus enabling synchronization between the source and target database systems.

[0046] Steps 501 through 511 are steps 401 through 411 in Figure 4. Additionally, the method of Figure 5 further includes step 513 of updating, for the selected application algorithm, the performance behavior determined in step 503. Additionally, steps 505 through 513 may be repeated for each change applied to one or more tables of the plurality of tables.

[0047] FIG. 6A is a flowchart of a method for determining performance behavior of an application algorithm according to an embodiment of the present invention.

[0048] The application algorithm may be executed a predefined number N of times in step 601 to apply data changes to the table each time, each applied data change having a size.

[0049] For each data change of the data changes, at least one performance parameter indicative of the performance of the execution of the application algorithm may be evaluated in step 603. For example, the execution time of the application algorithm may be measured for the application of each of the N changes.

[0050] In step 605, a data structure of N data points may be provided. The data structure indicates the performance behavior of the application algorithm. Each data point indicates a performance parameter and the associated size of a data change. Figure 6C shows, as an example, N=2 measured data points for two application algorithms App1 and App2.

[0051] FIG. 6B is a flowchart of a method for determining performance behavior of an application algorithm according to an embodiment of the present invention.

[0052] The method of Figure 6B includes steps 601 to 605 described above, as well as step 607. In step 607, the provided data structure representing the performance behavior of the application algorithm may be augmented with additional points. This may be performed, for example, using interpolation between N data points. This may be, for example, as shown in Figure 6C, where linear interpolation is performed between two data points for each of the application algorithms. The additional points may be any points along the dashed lines (interpolation).

[0053] FIG. 7 illustrates a general computerized system 700 suitable for implementing at least some of the method steps according to embodiments of the present invention.

[0054] It will be understood that the methods described herein are at least partially non-interactive and automated by methods of a computerized system, such as a server or embedded system. However, in exemplary embodiments, the methods described herein may be implemented in a (partially) interactive system. These methods may further be implemented in software 712, 722 (including firmware 722), hardware (processor) 705, or a combination thereof. In exemplary embodiments, the methods described herein are implemented in software as executable programs and executed by a specialized or general-purpose digital computer, such as a personal computer, workstation, minicomputer, or mainframe computer. Thus, the most general system 700 includes a general-purpose computer 701.

[0055] In an exemplary embodiment, from a hardware architecture perspective, as shown in FIG. 7 , a computer 701 includes a processor 705, a memory (main memory) 710 coupled to a memory controller 715, and one or more input and / or output (I / O) devices (or peripherals) 10 and 745 communicatively coupled via a local input / output controller 735. The input / output controller 735 can be, but is not limited to, one or more buses or other wired or wireless connections, as known in the art. The input / output controller 735 can have additional elements, omitted for simplicity, such as controllers, buffers (caches), drivers, repeaters, and receivers, to enable communication. Furthermore, the local interface can include address, control, and / or data connections to enable appropriate communication between the aforementioned components. As described herein, the I / O devices 10 and 745 can generally include any generalized cryptographic or smart card known in the art.

[0056] Processor 705 is a hardware device for executing software, particularly that stored in memory 710. Processor 705 can be a custom-made or commercially available processor, a central processing unit (CPU), a coprocessor among multiple processors associated with computer 701, a semiconductor-based microprocessor (in the form of a microchip or chipset), or generally any device for executing software instructions.

[0057] The memory 710 can include any one or combination of volatile memory elements (e.g., random access memory (RAM, such as DRAM, SRAM, SDRAM)) and non-volatile memory elements (e.g., ROM, erasable programmable read-only memory (EPROM), electronically erasable programmable read-only memory (EEPROM), programmable read-only memory (PROM)). It should be noted that the memory 710 can have a distributed architecture, where various components are located remotely from one another but can be accessed by the processor 705.

[0058] The software in memory 710 may include one or more separate programs, each of which includes an ordered list of executable instructions for implementing logical functions, particularly functions involved in embodiments of the present invention. In the example of Figure 7, the software in memory 710 includes instructions 712, e.g., instructions for managing a database, such as a database management system.

[0059] The software in memory 710 also typically includes a suitable operating system (OS) 711. The OS 711 essentially controls the execution of other computer programs, such as software 712, possibly for implementing the methods described herein.

[0060] The methods described herein may be in the form of a source program 712, an executable program 712 (object code), a script, or any other entity comprising a set of instructions 712 to be executed. In the case of a source program, the program must be translated via a compiler, assembler, interpreter, etc., which may or may not be contained within memory 710, to operate properly in conjunction with the OS 711. Furthermore, the methods may be written as an object-oriented programming language with classes of data and methods, or a procedural programming language with routines, subroutines, or functions, or a combination thereof.

[0061] In an exemplary embodiment, a conventional keyboard 750 and mouse 755 may be coupled to the input / output controller 735. Other output devices, such as I / O devices 745, may include, for example, but are not limited to, input devices such as a printer, scanner, microphone, etc. Finally, I / O devices 10 and 745 may further include devices that communicate both input and output, such as, but not limited to, a network interface card (NIC) or modulator / demodulator (for accessing other files, devices, systems, or networks), radio frequency (RF) or other transceivers, telephonic interfaces, bridges, routers, etc. I / O devices 10 and 745 may be any generalized encryption card or smart card known in the art. System 700 may further include a display controller 725 coupled to a display 730. In an exemplary embodiment, system 700 may further include a network interface for coupling to a network 765. Network 765 may be an IP-based network for communication between computer 701 and any external servers, clients, etc. via a broadband connection. Network 765 transmits and receives data between computer 701 and external systems 30, which may be involved in performing some or all of the steps of the methods discussed herein. In an exemplary embodiment, network 765 may be a managed IP network managed by a service provider. Network 765 may be implemented in a wireless manner using wireless protocols and technologies such as WiFi, WiMax, etc. Network 765 may also be a packet-switched network such as a local area network, wide area network, metropolitan area network, Internet network, or other similar type of network environment.The network 765 may be a fixed wireless network, a wireless local area network (WLAN), a wireless wide area network (WWAN), a personal area network (PAN), a virtual private network (VPN), an intranet, or other suitable network system, and includes devices for receiving and transmitting signals.

[0062] If computer 701 is a PC, workstation, intelligent device, etc., the software in memory 710 may further include a basic input output system (BIOS) 722. The BIOS is a set of essential software routines that initializes and tests hardware at startup, starts OS 711, and supports data transfer between hardware devices. The BIOS is stored in ROM so that it can be executed when computer 701 starts up.

[0063] When computer 701 is operating, processor 705 is configured to execute software 712 stored in memory 710, to communicate data to and from memory 710, and to generally control the operation of computer 701 in accordance with the software. The methods and OS 711 described herein are read by processor 705, possibly buffered within processor 705, and then executed, in whole or in part, but typically the latter.

[0064] 7, the methods can be stored on any computer-readable medium, such as storage 720, for use by or in connection with any computer-related system or method. Storage 720 can include disk storage, such as HDD storage.

[0065] The programs described herein are identified based on the application for which they are implemented in a particular embodiment of the invention, but it should be understood that any particular program nomenclature herein is used merely for convenience, and thus the invention should not be limited to use only in any particular application specified and / or implied by such nomenclature.

[0066] The present invention may be a system, a method, or a computer program product, or a combination thereof. The computer program product may include a computer-readable storage medium having stored thereon computer-readable program instructions for causing a processor to carry out aspects of the present invention.

[0067] A computer-readable storage medium may be a tangible device capable of retaining and storing instructions for use by an instruction execution device. The computer-readable storage medium may be, by way of example only, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or a suitable combination thereof. More specific examples of computer-readable storage media include portable computer diskettes, hard disks, RAM, ROM, EPROM (or flash memory), SRAM, CD-ROMs, DVDs, memory sticks, floppy disks, mechanically encoded devices having instructions recorded thereon, such as punch cards or ridge-in-groove structures, and suitable combinations thereof. As used herein, a computer-readable storage medium should not be construed as a transitory signal per se, such as an electric wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or an electrical signal transmitted over a wire.

[0068] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device or to an external computer or external storage device via a network (e.g., the Internet, a local area network, a wide area network, a wireless network, or a combination thereof). The network may be comprised of copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, edge servers, or a combination thereof. A network adapter card or network interface of each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage on a computer-readable storage medium within the respective computing / processing device.

[0069] The computer-readable program instructions for carrying out the operations of the present invention may be either source code or object code written in any combination of one or more programming languages, including assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk, C++, etc., and procedural programming languages ​​such as the "C" programming language and similar programming languages. The computer-readable program instructions may be executed entirely on the user's computer, as a standalone software package, or partially on the user's computer. Alternatively, the computer may be executed partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA) can execute computer-readable program instructions by utilizing state information of the computer-readable program instructions to personalize the computer-readable program instructions in order to carry out aspects of the present invention.

[0070] Aspects of the present invention are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0071] These computer-readable program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to create a machine, such that the instructions, executed by the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer-readable program instructions can also be stored in a computer-readable storage medium connectable to a computer, programmable data processing apparatus, or other device, or combination thereof, that functions in a particular way, such that the computer-readable storage medium having the instructions stored thereon constitutes one of an article of manufacture containing instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0072] Computer-readable program instructions, such as instructions to perform the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams on a computer, other programmable apparatus, or other device, can also be loaded into a computer, other programmable data processing apparatus, or other device to perform a series of operational steps on the computer, other programmable apparatus, or other device to produce a computer-implemented process.

[0073] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of executable implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or portion of instructions, which constitute one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions shown in the blocks may occur out of the order shown in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may be executed in the reverse order, depending on the functionality involved. It should also be noted that each block of the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, may be implemented by a special-purpose hardware-based system that performs the specified functions or operations or executes a combination of special-purpose hardware and computer instructions.

Claims

1. providing, by one or more processors, at least two application algorithms for applying changes to tables in a target database system; determining, by the one or more processors, for each application algorithm of the at least two application algorithms, a performance behavior of each application algorithm relative to a size of a change applied to the table by the respective application algorithm; receiving, by the one or more processors, a data modification request to apply modifications to the table; determining, by the one or more processors, the size of the change to the table; selecting, by the one or more processors, one of at least two application algorithms that provides optimal performance for the size based on the performance behavior of each application algorithm; applying, by the one or more processors, the changes to the table using the selected application algorithm that provides the optimal performance for the size; evaluating, by the one or more processors, performance of the selected application algorithm with application of the changes to the table; updating, by the one or more processors, the performance behavior of the selected application algorithm using the performance of the selected application algorithm and the size of the changes to the table; 11. A computer-implemented method comprising:

2. repeating, by the one or more processors, the determining, the selecting, and the applying of the size for each received data modification request for the table; dynamically updating, by the one or more processors, the performance behavior in the table; The computer-implemented method of claim 1 , further comprising:

3. determining, by the one or more processors, a respective performance behavior for each additional table of the target database system, such that each table of the target database system is associated with a respective performance behavior; repeating, by the one or more processors, the determining, the selecting, and the applying of the size for each received data modification request for the particular table of the target database system using the performance behavior associated with the particular table; The computer-implemented method of claim 1 , further comprising:

4. Determining the performance behavior of each application algorithm includes: executing, by the one or more processors, each of the application algorithms a predefined number N of times to respectively apply data changes to the table, each applied data change having a size; evaluating, by the one or more processors, for each of the data modifications, at least one performance parameter indicative of performance of the execution of the application algorithm; providing, by the one or more processors, a data structure of N data points representing the performance behavior, each data point indicating the at least one performance parameter and an associated size of the data change; The computer-implemented method of claim 1 , comprising:

5. The predefined number N is less than the maximum number of runs that can be set, constructing, by the one or more processors, a new data point in the data structure using interpolation of the N data points; The computer-implemented method of claim 4 further comprising:

6. The computer-implemented method of claim 4 , wherein the performance parameters are selected from the group consisting of execution time and memory usage.

7. The computer-implemented method of claim 1 , wherein the size of the change includes at least one of a number of records inserted, a number of records deleted, and a number of records updated.

8. The selecting the application algorithm comprises: determining, by the one or more processors, whether the performance of two application algorithms for the size is similar; selecting, by the one or more processors, one of the two application algorithms in response to determining that the performance of the two application algorithms for the size is similar; and The computer-implemented method of claim 1 , comprising:

9. The computer-implemented method of claim 1 , wherein the selected application algorithm is selected from the group consisting of a record bulk load based application and an individual record load based application.

10. providing, by the one or more processors, a source table associated with the table in a source database system, the source database system and the target database system configured to synchronize data between one another; The computer-implemented method of claim 1 , wherein the data change request is received in response to a data change being applied to the source table, thereby replicating the data change.

11. A computer program for causing a computer to execute program instructions, the program instructions comprising: program instructions providing at least two application algorithms for applying changes to tables in a target database system; program instructions for determining, for each of the at least two application algorithms, a performance behavior of each application algorithm relative to a size of a change applied to the table by the respective application algorithm; program instructions for receiving a data change request to apply changes to the table; program instructions for determining the size of the change to the table; program instructions for selecting one of at least two application algorithms that provides optimal performance for the size based on the performance behavior of each application algorithm; program instructions for applying the changes to the table using the selected application algorithm that provides the optimal performance for the size; program instructions for evaluating the performance of the selected application algorithm with application of the changes to the table; program instructions for updating the performance behavior of the selected application algorithm using the performance of the selected application algorithm and the size of the change to the table; a computer program comprising:

12. program instructions for repeating the program instructions for determining the size, the program instructions for selecting, and the program instructions for applying for each received data modification request for the table; program instructions for dynamically updating the performance behavior of the table; The computer program of claim 11 , further comprising:

13. program instructions for determining a respective said performance behavior for each additional table of the target database system, such that each table of the target database system is associated with a respective performance behavior; program instructions to repeat the program instructions to determine, select, and apply for each received data modification request for the particular table of the target database system using the performance behavior associated with the particular table; The computer program of claim 11 , further comprising:

14. The program instructions that determine the performance behavior of each application algorithm include: program instructions for executing the respective application algorithm a predefined number N of times to respectively apply data modifications to the table, each applied data modification having a size; program instructions for evaluating, for each of said data changes, at least one performance parameter indicative of the performance of said execution of said application algorithm; program instructions for providing a data structure of N data points representative of said performance behavior, each data point indicating said at least one performance parameter and an associated size of said data change; 12. The computer program of claim 11, comprising:

15. one or more computer processors; one or more computer-readable storage media; program instructions collectively stored on the one or more computer-readable storage media for execution by at least one of the one or more computer processors, the stored program instructions comprising: program instructions providing at least two application algorithms for applying changes to tables in a target database system; program instructions for determining, for each of the at least two application algorithms, a performance behavior of each application algorithm relative to a size of a change applied to the table by the respective application algorithm; program instructions for receiving a data change request to apply changes to the table; program instructions for determining the size of the change to the table; program instructions for selecting one of at least two application algorithms that provides optimal performance for the size based on the performance behavior of each application algorithm; program instructions for applying the changes to the table using the selected application algorithm that provides the optimal performance for the size; program instructions for evaluating the performance of the selected application algorithm with application of the changes to the table; program instructions for updating the performance behavior of the selected application algorithm using the performance of the selected application algorithm and the size of the change to the table; 2. A computer system comprising:

16. program instructions for repeating the program instructions for determining the size, the program instructions for selecting, and the program instructions for applying for each received data modification request for the table; program instructions for dynamically updating the performance behavior of the table; 16. The computer system of claim 15, further comprising:

17. program instructions for determining a respective said performance behavior for each additional table of the target database system, such that each table of the target database system is associated with a respective performance behavior; program instructions to repeat the program instructions to determine, select, and apply for each received data modification request for the particular table of the target database system using the performance behavior associated with the particular table; 16. The computer system of claim 15, further comprising:

Images