Aspects of the present disclosure relate to managing concurrent updates on data. A transactional update on at least one record within a data set is detected. A log is generated for the transactional update, the log including an image of the at least one record within the data set before the transactional update. A batch update is detected. A determination is made whether the batch update collides with the transactional update by referencing the log. In response to determining that the batch update collides with the transactional update, a collision policy is referenced. A collision action indicated in the collision policy is then issued.

A client application of a content management system provides instructions for synchronizing content items and placeholder items using a local file journal and updated file journal. The client application compares entries in the updated file journal to entries in the local file journal to determine modifications to make to content items or placeholder items stored in a shared content storage directory on the client device. Based on the result of the comparison, the client application replaces placeholder items with content items or replaces content items with placeholder items.

An information processing device includes a memory, and a processor coupled to the memory and configured to acquire a plurality of data from first databases, where the data are stored in the first databases in a first period, and identifiers are stored in the first databases in association with the data, where the first databases correspond to servers that perform manipulations on a plurality of records containing the data stored in a second database, and the identifiers indicate order of the manipulations, and store the data in a third database in order indicated by the identifiers.

A method and system for converting database applications into blockchain applications is disclosed. Multiple applications on different nodes can automatically perform global data consensus to prevent data conflicts using the embodiments described. One method involves monitoring databases as they is modified by database applications, to extract data operations from transaction logs, convert the data operations to a general format, and activate the smart contract on the blockchain to complete the data consensus check at multiple nodes. Each node monitors the blocks on blockchain and synchronizes the data back to database. In the case of conflicting data, the data is not able to pass consensus and synchronize with the other nodes in the blockchain. The local nodes automatically roll back when detecting invalid data.

The present disclosure involves systems, software, and computer implemented methods for configuring graph query parallelism for high system throughput. One example method includes receiving a query to be executed against a graph database. System properties are determined of a system in which the query is to be executed. Algorithmic properties are determined of at least one algorithm to be used to execute the query. Graph data statistics are determined for the graph database. Graph traversal estimations are determined for a first iteration of the graph query and an estimated cost model is determined for the first iteration based on the graph traversal estimations. Estimated thread boundaries are determined for performing parallel execution of the first iteration. Work packages of vertices to be processed during the execution of the first iteration are determined based on the first estimated cost model and the work packages are provided to a work package scheduler.

In a distributed system where a client's call to commit a transaction occurs outside the transaction's lock-hold interval, computation of timestamp information for the transaction is moved to a client library, while ensuring that no conflicting reads or writes are performed between a time of the computation and acquiring all locks for the transaction. The transaction is committed in phases, with each phase being initiated by the client library. Timestamp information is added to the locks to ensure that timestamps are generated during lock-hold intervals. An increased number of network messages is thereby overlapped with a commit wait period in which a write in a distributed database is delayed in time to ensure concurrency in the database.

Techniques for processing a request may include: providing tasks to a state machine framework, wherein the tasks perform processing of a workflow for servicing the request; generating, by the state machine framework, a state machine for processing the request, wherein the state machine includes states associated with the tasks, wherein generating the state machine may include automatically determining a first state transition of the state machine between a first and a second of the states; receiving the request; and responsive to receiving the request, performing first processing using the state machine to service the request. The framework may automatically generate triggers that drive the state machine to determine subsequent states in accordance with defined state transitions. State machine internal state information may be persistently stored and used in restoring the state machine to one of its states in connection processing of the command.

A database management system for controlling prioritized transactions, comprising: a processor adapted to: receive from a client module a request to write into a database item as part of a high-priority transaction; check a lock status and an injection status of the database item; when the lock status of the database item includes a lock owned by a low-priority transaction and the injection status is not-injected status: change the injection status of the database item to injected status; copy current content of the database item to an undo buffer of the low-priority transaction; and write into a storage engine of the database item.

For a first record of a batch of records, a first timestamp may be determined to be stored with the first record in a database into which the batch of records are to be loaded as part of a database loading process. For each remaining record of the batch of records, a future timestamp may be generated using the first timestamp, until a final timestamp of a final record of the batch of records is generated. For a load completion time at which the database loading process completes, prior to the final timestamp, a wait time until a batch completion time may be determined by comparing the load completion time and the final timestamp, and waiting for the wait time to reach the batch completion time. If the load completion time is at or after the final timestamp, the batch completion time may be reached at the load completion time.

Systems, methods, and computer-readable media for temporary reservation schemes, are provided. In embodiments, temporary reservations are inserted into non-relational datastore, and update records indicating changes to the non-relational datastore are streamed to processing nodes. The processing nodes store the update records in local expiration windows. The expiration windows are periodically polled for expired temporary reservations, which are then removed from the non-relational datastore. Other embodiments may be described and/or claimed.