Patent Description:
Data migration refers to the process of transferring data between storage types, formats, or computer systems. It is a key consideration for any system implementation, upgrade, or consolidation. In a typical example, data is stored in tables of a database. Over time, for various reasons, such as changes to the database schema, it may be necessary to migrate the data from one or more tables of a first database to one or more tables of a second database. For example, the migration may also include converting data from one schema to another schema. For large-scale applications, the migration may take several hours to days. Due to commercial, practical, or other reasons, it may be unrealistic to bring the database system offline during the migration. <CIT> discloses a method and system for online data migration.

A first aspect, comprising a system for live data migration, is defined with reference to claim <NUM>.

In some examples, the mutation table may indicate that a row of the at least one first table was modified by setting a Boolean value of a corresponding row of the mutation table to true.

In some examples, the diff table may have a same database schema as the second database schema.

In some examples, the storing the log of one or more data modifications to the one or more rows of the at least one first table during the migration in the commit log may comprise:
identifying a row identifier, a name, a number, or a value of the one or more rows of the at least one first table that was modified.

A second aspect, comprising a computer-implemented method, is defined with reference to claim <NUM>.

In some examples, the storing the log of one or more data modifications to the one or more rows of the at least one first table during the migration in the commit log may comprise: identifying a row identifier, a name, a number, or a value of the one or more rows of the at least one first table that was modified.

These and other features of the systems, methods, and non-transitory computer readable media disclosed herein, as well as the methods of operation and functions of the related elements of structure and the combination of parts and economies of manufacture, will become more apparent upon consideration of the following description and the appended claims with reference to the accompanying drawings, all of which form a part of this specification, wherein like reference numerals designate corresponding parts in the various figures. It is to be expressly understood, however, that the drawings are for purposes of illustration and description only and are not intended as a definition of the limits of the invention.

In some embodiments, the systems, methods, and non-transitory computer readable media are configured to determine a second query for accessing the at least one row during the migration; determine that the at least one row has been modified based at least in part on the mutation table; determine that the row has been deleted from the second table; and provide a null value in response to the second query.

These and other features of the systems, methods, and non-transitory computer readable media disclosed herein, as well as the methods of operation and functions of the related elements of structure and the combination of parts and economies of manufacture, will become more apparent upon consideration of the following description and the appended clauses with reference to the accompanying drawings, all of which form a part of this specification, wherein like reference numerals designate corresponding parts in the various figures. It is to be expressly understood, however, that the drawings are for purposes of illustration and description only and are not intended as a definition of the limits of the invention.

Certain features of various embodiments of the present technology are set forth with particularity in the appended clauses. A better understanding of the features and advantages of the technology will be obtained by reference to the following detailed description that sets forth illustrative embodiments, in which the principles of the invention are utilized, and the accompanying drawings of which:.

The figures depict various embodiments of the disclosed technology for purposes of illustration only, wherein the figures use like reference numerals to identify like elements. One skilled in the art will readily recognize from the following discussion that alternative embodiments of the structures and methods illustrated in the figures can be employed without departing from the principles of the disclosed technology described herein.

Under conventional approaches, processing queries while migrating a live database from one schema to another can pose several challenges. In one example, users may submit queries that add, modify, or delete data stored in the database tables being migrated. In this example, computing systems tasked with processing such queries must be able to accurately track changes to the data so that the most up-to-date version of the data can be provided in response to any queries accessing the modified data.

A clauseed solution rooted in computer technology overcomes problems specifically arising in the realm of computer technology. In various implementations, a computing system is configured to process read and write queries to a database while migrating tables in the database from an old schema to a new schema. For example, in some implementations, the system can maintain a mutation table that tracks any changes made to fields (e.g., rows, columns, or both) in the database tables during the migration. When a query for modifying a field in a database table is received, the system can modify the appropriate field in the database table that corresponds to the new schema. The system can also update the mutation table to indicate the modification. When a query for accessing the field is received, the system can determine whether the field was modified based on the mutation table. If the field was modified, the system returns data stored in the field from the database table corresponding to the new schema.

<FIG> illustrates a block diagram of an example of a system <NUM> for performing live data migrations, according to embodiments of the present disclosure. The example system shown in <FIG> includes a computing system <NUM> and a computing device <NUM> that can communicate with one another over a network <NUM>. The computing system <NUM> may be configured to implement one or more of the various embodiments described herein. Depending on the implementation, the computing device <NUM> may be any computing device having one or more processors, e.g., a mobile device. The network <NUM> may include one or more computer networks (e.g., the Internet, local area networks, etc.) or other transmission mediums. Such networks may be wired and/or wireless. The system <NUM> may include more, fewer, or alternative components than those shown in <FIG>.

In various embodiments, the computing device <NUM> can be configured to process queries that are received from various computing devices, e.g., the computing device <NUM>. Such queries may involve requesting data that is stored in one or more tables of a database, writing new data in the one or more tables of the database, modifying existing data in the one or more tables of the database, and/or deleting existing data in the one or more tables of the database. The computing device <NUM> can process such queries and provide data that is responsive to the queries. In some instances, the computing device <NUM> may be running one or more software applications <NUM> that have been configured to query data that is stored in a particular database, e.g., the database <NUM>.

In various embodiments, a live migration of data from one database, e.g., the database <NUM>, to another database, e.g., the database <NUM>, may involve transferring (or copying) data from one or more tables of the database <NUM> to one or more tables of the database <NUM>. In some instances, one or more tables of the database <NUM> may be configured for a first schema while the corresponding tables in the database <NUM> may be configured for a second schema. In one example, <FIG> illustrates an example table <NUM> in the database <NUM>. The example table <NUM> includes a set of columns "First Name", "Last Name", "Street", "City", and "State". <FIG> illustrates an example table <NUM> in the database <NUM>. The example table <NUM> includes a fewer set of columns than the table <NUM> and includes columns labeled "First Name", "Last Name", and "Address". The tables <NUM> and <NUM> are provided merely as examples and, naturally, any form of data can be migrated from one database to another regardless of being migrated between the same schema or different schemas.

The term "database" may refer to any data structure for storing and/or organizing data, including, but not limited to, relational databases (Oracle database, MySQL database, etc.), spreadsheets, XML files, and text file, among others. In some embodiments, a database schema of a database system is its structure described in a formal language supported by the database management system. The term "schema" refers to the organization of data as a blueprint of how the data is constructed (divided into database tables in the case of relational database).

In general, when performing a live migration, the data that was available in the database from which data is being migrated, e.g., the database <NUM>, including any changes made to the data during the migration, should be remain accessible while the migration is process. Such reliability is typically needed so that existing applications <NUM> (or resources) that rely on the data can continue to operate until the applications <NUM> have been modified or upgraded to utilize the database (e.g., database schema) to which the data is being migrated, e.g. the database <NUM>. In various embodiments, the computing system <NUM> (or another computing system) is configured to migrate live data, for example, from one or more first databases, e.g., the database <NUM>, to one or more second databases, e.g., the database <NUM>, without interrupting the operations of existing applications <NUM> (or resources) that rely on the data being migrated. In general, such migration may involve transferring (e.g., copying, moving, etc.) data stored in one or more tables in the database <NUM> to one or more corresponding tables in the database <NUM>. Various approaches discussed below allow for performing a live migration of data in such computing environments. Such approaches can be used to perform the live migration of data while ensuring that existing applications, or resources, that rely on the data can continue to operate without interruption. Depending on the implementation, the approaches may be used either alone or in combination.

<FIG> illustrates a block diagram of an example environment <NUM> for performing live data migrations, according to embodiments of the present disclosure. <FIG> shows the computing system <NUM> and the computing device <NUM> as described in <FIG>. As mentioned, the computing system <NUM> and the computing device <NUM> can interact with one another over the network <NUM>. <FIG> also illustrates an example old table <NUM> in a first database, e.g., the database <NUM> of <FIG>, and an example new table <NUM> in a second database, e.g., the database <NUM> of <FIG>. In this example, data from the old table <NUM> is being migrated to the new table <NUM>.

<FIG> provides one example approach for migrating data from old table <NUM> to new table <NUM> in a live production environment <NUM>. As mentioned, the approaches described herein can be adapted to migrate data from the old table <NUM> to the new table <NUM> regardless of whether the tables <NUM> and <NUM> have the same schema or different schemas. In this example, one or more applications <NUM> (or resources) running on the computing device <NUM> may submit queries to the computing system <NUM>. These application(s) <NUM> may be configured to query data from various database table(s) having a first schema, e.g., the database <NUM> of <FIG>. As mentioned, such queries may involve operations to access data from tables and/or operations that write data to tables.

In various embodiments, to ensure that operation of the application(s) is not interrupted during the live migration, the computing system <NUM> is tasked with processing the submitted queries using the most recent, or up-to-date, data. To do so, the computing system <NUM> utilizes a separate mutation table <NUM> to keep track of data to which write operations have been performed during the migration. The mutation table is configured to track whether a particular row has been modified during the migration. In one example, the mutation table <NUM> may store a row identifier (e.g., name, number, value, etc.) and a corresponding Boolean value indicating whether a write operation has been performed on the row during the migration.

When performing the migration, in some embodiments, the computing system <NUM> copies over each field in the old table <NUM> to the new table <NUM>. A field may be referenced by a row identifier and a column identifier, for example. In such embodiments, when copying fields, the computing system <NUM> can determine whether the row corresponding to the field was previously modified by any write operations that were performed during the migration. For example, the computing system <NUM> can reference the mutation table <NUM> to determine whether the corresponding Boolean value for the row is true. In this example, a true value in the mutation table <NUM> indicates that the row was modified. If the field was previously modified, then the field is not copied to the new table <NUM> so that any up-to-date values already stored in the new table <NUM> are not overwritten. Otherwise, if the field was not previously modified, the computing system <NUM> copies the field from the old table <NUM> to the new table <NUM>. As mentioned, the old table <NUM> and new table <NUM> may have different schemas (e.g., different columns, etc.). Thus, in various embodiments, the computing system <NUM> can determine the appropriate location in which the field being copied is to be stored, for example, based on a pre-defined mapping of columns between the different schemas. The computing system <NUM> can further be configured to parse the data being migrated from one table, e.g., the table <NUM>, to another table, e.g., the table <NUM> based on the different table schemas so that the parsed portions of the data are migrated, or populated, to the appropriate locations (e.g., fields, rows, columns, etc.) based on the respective schema of the table to which the data is being migrated.

In some embodiments, when a query for performing a write operation (e.g., modifying existing rows, deleting rows, etc.) to the old table <NUM> is received, the computing system <NUM> is configured to perform the write operation on the new table <NUM>. In one example, a query that modifies row n (e.g., n being some numerical value) in the old table <NUM> can be executed against the new table <NUM> so that row n in new table <NUM> is modified instead of old table <NUM>. In such embodiments, the computing system <NUM> can also update the mutation table <NUM> to indicate that row n was modified during the migration, e.g., by setting the corresponding Boolean value for row n in the mutation table <NUM> to "true". In such embodiments, performing the write operations on the new table <NUM> allows the computing system <NUM> to store the most recent or up-to-date data in the new table <NUM> to which data is being migrated which prevents loss of data during the live migration. In some instances, the write operation may delete one or more rows from a table. In such instances, the row can be deleted in the new table <NUM> to which the data is being migrated. Similarly, the mutation table <NUM> can be updated to reflect the modification (e.g., deletion) as described above. When a query for accessing the deleted row is received, the computing system <NUM> can determine that the row has been modified using the mutation table <NUM>, for example. The computing system <NUM> can further determine that the row is no longer present in the new table <NUM>. In this example, the computing system <NUM> can provide a response (e.g., null value) indicating that the row is no longer available for access.

In some embodiments, when a query for performing a read operation is received (e.g., reading a row of data), the computing system <NUM> can determine if the row being read was previously modified, for example, using the mutation table <NUM>. For example, the computing system <NUM> can reference the mutation table <NUM> to determine whether the corresponding Boolean value for the row is true. In this example, a true value in the mutation table <NUM> indicates that the row was modified. If the row was previously modified, then the computing system <NUM> provides data corresponding to the row from the new table <NUM> to which data is being migrated. Otherwise, if the row has not been modified, then the computing system <NUM> provides data corresponding to the row from the old table <NUM> from which data is being migrated. Such coordination of read operations allows the computing system <NUM> to process queries using the most recent or up-to-date data that is available in the live production environment.

<FIG> provides the approach for migrating data from old table <NUM> to new table <NUM> in a live production environment <NUM>. As mentioned, the approaches described herein can be adapted to migrate data from the old table <NUM> to the new table <NUM> regardless of whether the tables <NUM> and <NUM> have the same schema or different schemas. As mentioned, in various embodiments, to ensure that operation of various application(s) is not interrupted during the live migration, the computing system <NUM> is tasked with processing submitted queries using the most recent, or up-to-date, data. The computing system <NUM> utilizes a separate mutation table <NUM> to keep track of data to which write operations have been performed during the migration, as described above. In such embodiments, since the old table <NUM> becomes immutable once the live migration starts, an end of the migration can be determined when all old rows of the old table <NUM> have been migrated. During the migration of the old table <NUM>, one or more updates to the old table <NUM> are recorded and logged chronologically such that the updates can be applied after the migration according to the chronological order.

The computing system <NUM> utilizes a separate diff table <NUM> to store data provided with write operations that were submitted from various client devices, e.g., the computing device <NUM>. In some embodiments, the diff table <NUM> has the same schema as the new table <NUM> to which data is being migrated. The computing device <NUM> also utilizes a commit log <NUM> that logs data describing the various rows to which write operations have been performed during the migration,.

The commit log <NUM> keeps a log of all rows to which write operations were performed in chronological order,.

The commit log <NUM> stores information identifying a row to which a write operation was performed (e.g., row identifier, name, number, value, etc.) along with a corresponding timestamp indicating when the write operation was performed.

When a query for performing a write operation (e.g., modifying existing rows, deleting rows, etc.) to the old table <NUM> is received, the computing system <NUM> is configured to perform the write operation on the diff table <NUM>. In one example, a query that modifies row n (e.g., n being some numerical value) in the old table <NUM> can be executed against the diff table <NUM> so that row n in the diff table <NUM> is modified instead of old table <NUM>. The computing system <NUM> also updates the mutation table <NUM> to indicate that row n was modified during the migration, e.g., by setting the corresponding Boolean value for row n in the mutation table <NUM> to "true".

The computing system <NUM> also updates the commit log <NUM> to include information identifying the row to which the write operation was performed along with a corresponding timestamp indicating when the write operation was performed.

When performing the migration, in some embodiments, the computing system <NUM> migrates each field in the old table <NUM> to the new table <NUM>. A field may be referenced by a row identifier and a column identifier, for example. For example, the computing system <NUM> can copy each field in the old table <NUM> to a corresponding field in the new table <NUM>. The computing system <NUM> then utilizes the commit log <NUM> to migrate rows to which write operations were performed.

For each row in the commit log <NUM>, the computing system <NUM> chronologically applies the events in the commit log <NUM> onto the new table <NUM>.

When a query for performing a read operation is received (e.g., reading a row of data), the computing system <NUM> determines if the row being read was previously modified, using the mutation table <NUM>. If the row was previously modified, then the computing system <NUM> provides data corresponding to the row from the diff table <NUM>. Otherwise, if the row has not been modified, then the computing system <NUM> provides data corresponding to the row from the old table <NUM> from which data is being migrated.

<FIG> provides another example approach for migrating data from old table <NUM> to new table <NUM> in a live production environment <NUM>. As mentioned, the approaches described herein can be adapted to migrate data from the old table <NUM> to the new table <NUM> regardless of whether the tables <NUM> and <NUM> have the same schema or different schemas. As mentioned, in various embodiments, to ensure that operation of various application(s) is not interrupted during the live migration, the computing system <NUM> is tasked with processing submitted queries using the most recent, or up-to-date, data.

In some embodiments, when a query for performing a write operation (e.g., modifying existing rows, deleting rows, etc.) to the old table <NUM> is received, the computing system <NUM> is configured to perform the write operation on the new table <NUM>. In one example, a query that modifies row n (e.g., n being some numerical value) in the old table <NUM> can be executed against the new table <NUM> so that row n in the new table <NUM> is modified. Further, in such embodiments, the computing system <NUM> can also update the old table <NUM> based on the write operation. In some instances, the schemas of old table <NUM> and new table <NUM> may differ. In such instances, data included in any new columns in the new table <NUM> may be omitted from the old table <NUM>.

In the example of <FIG>, the computing system <NUM> can perform the migration without relying on any tables (or logs). For example, when migrating a field from the old table <NUM> to the new table <NUM>, in some embodiments, the computing system <NUM> determines whether the row corresponding to the field already exists in the new table <NUM>. If the row does not exist in the new table <NUM>, the computing system <NUM> migrates the field to the new table <NUM>.

In some embodiments, when a query for performing a read operation is received (e.g., reading a row of data), the computing system <NUM> provides the requested data (e.g., row) from the old table <NUM>.

<FIG> illustrates a flowchart of an example method <NUM> for live data migration, according to various embodiments of the present disclosure. The method <NUM> may be implemented in various environments including, for example, the environment <NUM> of <FIG>. The operations of method <NUM> presented below are intended to be illustrative. Depending on the implementation, the example method <NUM> may include additional, fewer, or alternative steps performed in various orders or in parallel. The example method <NUM> may be implemented in various computing systems or devices including one or more processors.

At block <NUM>, at least one first table of a first database schema is migrated to at least one second table of a second database schema. At block <NUM>, a determination is made of a query for modifying the first table during the migration. At block <NUM>, the second table is modified based at least in part on the query. At block <NUM>, the mutation table is updated to describe the modification, wherein the mutation table at least describes the modification.

The techniques described herein are implemented by one or more special-purpose computing devices. The special-purpose computing devices may be hard-wired to perform the techniques, or may include circuitry or digital electronic devices such as one or more application-specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs) that are persistently programmed to perform the techniques, or may include one or more hardware processors programmed to perform the techniques pursuant to program instructions in firmware, memory, other storage, or a combination. The special-purpose computing devices may be desktop computer systems, server computer systems, portable computer systems, handheld devices, networking devices or any other device or combination of devices that incorporate hard-wired and/or program logic to implement the techniques.

Computing device(s) are generally controlled and coordinated by operating system software, such as iOS, Android, Chrome OS, Windows XP, Windows Vista, Windows <NUM>, Windows <NUM>, Windows Server, Windows CE, Unix, Linux, SunOS, Solaris, iOS, Blackberry OS, VxWorks, or other compatible operating systems. In other embodiments, the computing device may be controlled by a proprietary operating system. Conventional operating systems control and schedule computer processes for execution, perform memory management, provide file system, networking, I/O services, and provide a user interface functionality, such as a graphical user interface ("GUI"), among other things.

<FIG> is a block diagram that illustrates a computer system <NUM> upon which any of the embodiments described herein may be implemented. The computer system <NUM> includes a bus <NUM> or other communication mechanism for communicating information, one or more hardware processors <NUM> coupled with bus <NUM> for processing information. Hardware processor(s) <NUM> may be, for example, one or more general purpose microprocessors.

The computer system <NUM> also includes a main memory <NUM>, such as a random access memory (RAM), cache and/or other dynamic storage devices, coupled to bus <NUM> for storing information and instructions to be executed by processor <NUM>. Such instructions, when stored in storage media accessible to processor <NUM>, render computer system <NUM> into a special-purpose machine that is customized to perform the operations specified in the instructions.

The computer system <NUM> further includes a read only memory (ROM) <NUM> or other static storage device coupled to bus <NUM> for storing static information and instructions for processor <NUM>. A storage device <NUM>, such as a magnetic disk, optical disk, or USB thumb drive (Flash drive), etc., is provided and coupled to bus <NUM> for storing information and instructions.

The computer system <NUM> may be coupled via bus <NUM> to a display <NUM>, such as a cathode ray tube (CRT) or LCD display (or touch screen), for displaying information to a computer user. In some embodiments, the same direction information and command selections as cursor control may be implemented via receiving touches on a touch screen without a cursor.

The computing system <NUM> may include a user interface module to implement a GUI that may be stored in a mass storage device as executable software codes that are executed by the computing device(s). This and other modules may include, by way of example, components, such as software components, object-oriented software components, class components and task components, processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays, and variables.

In general, the word "module," as used herein, refers to logic embodied in hardware or firmware, or to a collection of software instructions, possibly having entry and exit points, written in a programming language, such as, for example, Java, C or C++. A software module may be compiled and linked into an executable program, installed in a dynamic link library, or may be written in an interpreted programming language such as, for example, BASIC, Perl, or Python. It will be appreciated that software modules may be callable from other modules or from themselves, and/or may be invoked in response to detected events or interrupts. Software modules configured for execution on computing devices may be provided on a computer readable medium, such as a compact disc, digital video disc, flash drive, magnetic disc, or any other tangible medium, or as a digital download (and may be originally stored in a compressed or installable format that requires installation, decompression or decryption prior to execution). Such software code may be stored, partially or fully, on a memory device of the executing computing device, for execution by the computing device. Software instructions may be embedded in firmware, such as an EPROM. It will be further appreciated that hardware modules may be comprised of connected logic units, such as gates and flip-flops, and/or may be comprised of programmable units, such as programmable gate arrays or processors. The modules or computing device functionality described herein are preferably implemented as software modules, but may be represented in hardware or firmware. Generally, the modules described herein refer to logical modules that may be combined with other modules or divided into sub-modules despite their physical organization or storage.

The computer system <NUM> may implement the techniques described herein using customized hard-wired logic, one or more ASICs or FPGAs, firmware and/or program logic which in combination with the computer system causes or programs computer system <NUM> to be a special-purpose machine. According to one embodiment, the techniques herein are performed by computer system <NUM> in response to processor(s) <NUM> executing one or more sequences of one or more instructions contained in main memory <NUM>. Execution of the sequences of instructions contained in main memory <NUM> causes processor(s) <NUM> to perform the process steps described herein.

The term "non-transitory media," and similar terms, as used herein refers to any media that store data and/or instructions that cause a machine to operate in a specific fashion. Such non-transitory media may comprise non-volatile media and/or volatile media. Common forms of non-transitory media include, for example, a floppy disk, a flexible disk, hard disk, solid state drive, magnetic tape, or any other magnetic data storage medium, a CD-ROM, any other optical data storage medium, any physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, NVRAM, any other memory chip or cartridge, and networked versions of the same.

Non-transitory media is distinct from but may be used in conjunction with transmission media. Transmission media participates in transferring information between non-transitory media.

The instructions received by main memory <NUM> may retrieves and executes the instructions.

The computer system <NUM> also includes a communication interface <NUM> coupled to bus <NUM>. Communication interface <NUM> provides a two-way data communication coupling to one or more network links that are connected to one or more local networks. As another example, communication interface <NUM> may be a local area network (LAN) card to provide a data communication connection to a compatible LAN (or WAN component to communicated with a WAN).

A network link typically provides data communication through one or more networks to other data devices. For example, a network link may provide a connection through local network to a host computer or to data equipment operated by an Internet Service Provider (ISP). The ISP in turn provides data communication services through the world wide packet data communication network now commonly referred to as the "Internet". Local network and Internet both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link and through communication interface <NUM>, which carry the digital data to and from computer system <NUM>, are example forms of transmission media.

The computer system <NUM> can send messages and receive data, including program code, through the network(s), network link and communication interface <NUM>. In the Internet example, a server might transmit a requested code for an application program through the Internet, the ISP, the local network and the communication interface <NUM>.

Each of the processes, methods, and algorithms described in the preceding sections may be embodied in, and fully or partially automated by, code modules executed by one or more computer systems or computer processors comprising computer hardware. The processes and algorithms may be implemented partially or wholly in application-specific circuitry.

The various features and processes described above may be used independently of one another, or may be combined in various ways. All possible combinations and sub-combinations are intended to fall within the scope of this disclosure. In addition, certain method or process blocks may be omitted in some implementations. The methods and processes described herein are also not limited to any particular sequence, and the blocks or states relating thereto can be performed in other sequences that are appropriate. For example, described blocks or states may be performed in an order other than that specifically disclosed, or multiple blocks or states may be combined in a single block or state. The example blocks or states may be performed in serial, in parallel, or in some other manner. Blocks or states may be added to or removed from the disclosed example embodiments. The example systems and components described herein may be configured differently than described. For example, elements may be added to, removed from, or rearranged compared to the disclosed example embodiments.

Conditional language, such as, among others, "can," "could," "might," or "may," unless specifically stated otherwise, or otherwise understood within the context as used, is generally intended to convey that certain embodiments include, while other embodiments do not include, certain features, elements and/or steps. Thus, such conditional language is not generally intended to imply that features, elements and/or steps are in any way required for one or more embodiments or that one or more embodiments necessarily include logic for deciding, with or without user input or prompting, whether these features, elements and/or steps are included or are to be performed in any particular embodiment.

Any process descriptions, elements, or blocks in the flow diagrams described herein and/or depicted in the attached figures should be understood as potentially representing modules, segments, or portions of code which include one or more executable instructions for implementing specific logical functions or steps in the process. Alternate implementations are included within the scope of the embodiments described herein in which elements or functions may be deleted, executed out of order from that shown or discussed, including substantially concurrently or in reverse order, depending on the functionality involved, as would be understood by those skilled in the art.

Claim 1:
A system (<NUM>) for live data migration, the system comprising:
one or more processors (<NUM>); and
memory storing instructions that, when executed by the one or more processors, cause the system to perform:
migrating at least one first table of a first database schema to at least one second table of a second database schema, the migrating comprising:
receiving a query for modifying the at least one first table during the migration;
tracking data modifications to one or more rows of the at least one first table based at least in part on the query during the migration in a mutation table, wherein the mutation table indicates whether a row of the at least one first table was modified in a corresponding row of the mutation table;
storing data associated with the data modification to the one or more rows of the at least one first table in a separate diff table, wherein the diff table stores data associated with a data modification to a row of the at least one first table in a corresponding row of the diff table;
storing a log of one or more data modifications to the one or more rows of the at least one first table during the migration in a commit log by providing a timestamp indicating when the one or more rows of the at least one first table was or were modified;
determining, using the mutation table, whether a particular row of the at least one first table was modified during the migration ;
if the particular row was determined to be modified, chronologically transferring or copying, based on timestamps in the commit log, data stored in the diff table corresponding to the particular row to a corresponding row of the at least one second table; and
if the particular row was determined not to be modified, transferring or copying data of the particular row to the corresponding row of the at least one second table.