Abstract: A cluster of nodes can receive a request to perform a logging operation of a distributed data storage application. The logging operation can include writing of data to a secondary storage of each of the nodes of the plurality of nodes. The request can include an indication of a durability mode to use for the logging operation. The logging operation can be initiated at each node of the plurality of nodes according to the indication of the durability mode, a completion callback can be run at each node of the plurality of nodes according to the indication of the durability mode, a global durability state and a global commit state can be determined for the cluster, and a reply can be returned to the request once the global durability state and global commit state are consistent with the indication of the durability mode to be used for the logging operation.

Abstract: An approach for providing flexible durability operations for a data storage application can include requests to perform logging operations of data storage application having an indication of a durability mode to use for the logging operation. The logging operation can be initiated according to the indication of the durability mode and a callback indicating log write completion can be called according to the indication of the durability mode.

Abstract: Communication resumption information can be retained nodes of a cluster of nodes that form a distributed computing system. The communication resumption information can be exchanged between a node of the cluster and a peer node of the cluster after resumption of communication following a loss of communication between the node and the peer node. A determination of whether communication between the node and the peer node can be reestablished without losing messages can include comparing the communication resumption information received by the node from the peer node with the communication resumption information retained at the node. Communication between the node and the peer node can be resumed based when the determining indicates that communication between the node and the peer node can be reestablished without losing messages.

Abstract: A computing system in data communication with a plurality of nodes that make up a distributed computing cluster can detect an absence of communication from a node of the plurality of nodes over a time period that exceeds a predefined threshold time period. The computing system can query an instance of a central topology manager for the plurality of nodes regarding liveness of the node from which the absence of communication was detected and can attempting to re-initiate communication with the node when the instance of the central topology manager indicates that the node is live.

Abstract: A method for reclaiming memory resources may include segmenting a plurality of memory resources in an in-memory database into a first resource partition and a second resource partition; generating, for the first resource partition, a first heap containing a first plurality of memory resources sorted based on an age of data occupying the first plurality of memory resources; generating, for the second resource partition, a second heap containing a second plurality of memory resources sorted based on an age of data occupying the second plurality of memory resources; and when a shortage of memory resources is detected, identifying, from the first heap, a first memory resource containing a least recently used data, identifying, from the second heap, a second memory resource containing a least recently used data, and reclaiming the first memory resource and/or the second memory resource. Related systems and articles of manufacture are also disclosed.

Abstract: A central processing unit (CPU) forming part of a computing device, initiates execution of code associated with each of a plurality of objects used by a worker thread. The CPU has an associated cache that is split into a plurality of slices. It is determined, by a cache slice allocation algorithm for each object, whether any of the slices will be exclusive to or shared by the object. Thereafter, for each object, any slices determined to be exclusive to the object are activated such that the object exclusively uses such slices and any slices determined to be shared by the object are activated such that the object shares or is configured to share such slices.

Abstract: Deleting a data record from the second level storage or main store is disclosed. A look-up is performed for the data record in the first level storage, where the data record is defined by a row identifier. If the row identifier is found in the first level storage, a look-up is performed for an updated row identifier representing an update of the data record in the second level storage and the main store, the update of the data record being defined by an updated row identifier. If the updated row identifier is found in the second level storage, an undo log is generated from the first level storage to invalidate a row identifier of the row identifier. A flag is generated representing an invalid updated row identifier, and a redo log is generated to restore the data record in the first level storage.

Abstract: The subject matter disclosed herein provides methods for materializing data from an in-memory array to one or more pages. An in-memory array holding a column of data can be maintained. One or more pages can be maintained. Each of the one or more pages can have one or more rows for storing the column of data. At least one of the one or more pages can be marked for materialization. The column of data can be materialized by copying the data from the in-memory array to the one or more rows of the one or more pages. The materializing can be based on the marking. Related apparatus, systems, techniques, and articles are also described.

Abstract: A plurality of transactions is handled in a database. Each transaction includes a plurality of operations on at least one record in the database with at least two of the transactions being handled concurrently. Thereafter, a temporary timestamp is assigned to each record. The temporary timestamp are based, at least in part, on the corresponding transaction. Further, a final timestamp is assigned to each record with a commit operation. It can later be determined, using a visibility function and based on the assigned temporary timestamps and final timestamps, which of the records are visible in a consistent view for a first transaction. Based on such determination, access can be provided to those records determined to be visible to be accessed to the first transaction.

Abstract: Disclosed herein are system, method, and computer program product embodiments for directly restoring a database from a log volume. An embodiment operates by reading one or more database transaction log records from a log volume. The embodiment then loads from a database table persistent storage one or more pages containing rows in the database table that will be read from or written to by the one or more database transaction log records. The embodiment then loads a dictionary for each column associated with the one or more database transaction log records. The embodiment then applies the one or more database transaction log records directly into the one or more loaded pages and the one or more dictionaries. Each dictionary and page modified in memory is then written to the database table persistent storage when a savepoint operation is performed.

Abstract: A plurality of transactions are handled in a database. Each transaction comprises a plurality of operations on at least one record in the database with at least two of the transactions being handled concurrently. Thereafter, a temporary timestamp is assigned to each record that is based, at least in part, on the corresponding transaction. A first transaction among the plurality of transactions is subsequently committed. Afterwards, re-stamping of at least one commit timestamp modified by the first transaction is delegated. Related apparatus, systems, techniques and articles are also described.

Abstract: A database upon opening each of at least one cursor for a transaction, assigns each statement forming part of a transaction a statement sequence number (SSN) involving at least one row of the database. Thereafter, temporary timestamps are assigned to the at least one row using a transaction identifier and the corresponding SSN. Further, active cursors are monitored such that a final timestamp is prevented from being associated with each row until it has no remaining cursors. Related apparatus, systems, techniques and articles are also described.

Abstract: Data records of a data set can be stored in multiple main part fragments retained in on-disk storage. Each fragment can include a number of data records that is equal to or less than a defined maximum fragment size. Using a compression that is optimized for each fragment, each fragment can be compressed. After reading at least one of the fragments into main system memory from the on-disk storage, an operation can be performed on the fragment or fragments while the in the main system memory.

Abstract: Log records are accessed as part of a database operation in a database. The log records log insert, update, and delete operations in the database and include, for each row, a row position, a fragment identifier (ID), and a row ID. Thereafter, as part of the database operation, rows specified by the log records are located by: using the fragment identifier and the row position within the corresponding record of the log if the fragment with the corresponding fragment identifier is still available, otherwise, using the row identifier within the corresponding record of the log to look up the row position in an index of a corresponding row identifier column. The database operation is then finalized using the located rows. Related apparatus, systems, techniques and articles are also described.

Abstract: Disclosed herein are system, method, and computer program product embodiments for exporting and importing database tables in a database management system using multi-version concurrency control (MVCC). An embodiment operates by first initiating an export of a database table in the database management system. During the export transaction, temporary creation and deletion timestamps are identified from MVCC information associated with each row in the database table. Each temporary timestamp is associated with a database transaction. A timestamp map is then generated that associates the identified temporary timestamps with commit timestamps of the associated transactions. The database table, associated MVCC information, timestamp map, and snapshot timestamp of the export transaction are written to a binary file.

Abstract: Each of a plurality of database objects can be assigned to a specific message-passing worker of a plurality of message-passing workers, each executing on a first logical core that shares with at least a second logical core one or more resources of a physical processor core of a plurality of physical processor cores. The second logical core can execute a job worker of a plurality of j ob workers that implement procedural code. Exclusive write access can be provided to a database object of the plurality of database objects via a message-passing worker of the plurality of message-passing workers while read-only access is provided to any database object of the plurality of database objects via any of the plurality of job workers. Operations can be executed by the message-passing worker in an order in which request messages are received in a message queue of the message-passing worker.

Abstract: Deleting a data record from the second level storage or main store is disclosed. A look-up is performed for the data record in the first level storage, where the data record is defined by a row identifier. If the row identifier is found in the first level storage, a look-up is performed for an updated row identifier representing an update of the data record in the second level storage and the main store, the update of the data record being defined by an updated row identifier. If the updated row identifier is found in the second level storage, an undo log is generated from the first level storage to invalidate a row identifier of the row identifier. A flag is generated representing an invalid updated row identifier, and a redo log is generated to restore the data record in the first level storage.

Abstract: A plurality of data records that comprise a data set can be stored in a plurality of main part fragments such that each main part fragment includes a subset of the set of data records. Each fragment of the plurality of main part fragments can be assigned a relative data temperature. A newly arrived data record for storage in the data set can be placed in a delta part, and a merge can be performed to add the newly arrived data record to a corresponding main part fragment. The performing of the merge can occur more quickly if the corresponding main part fragment has a higher relative data temperature than if the corresponding main part fragment has a lower relative data temperature.

Abstract: Disclosed herein are system, method, and computer program product embodiments for managing non-uniform memory access (NUMA) in a database management system. An embodiment operates by receiving a request to load data from a disk into an in-memory database. An optimal one of the plurality of nodes onto which to load the data from the disk based on a system state is determined. It is determined whether the optimal node has sufficient free local memory in a free list to store the data. If the optimal node does not have sufficient free list memory, a memory allocation is requested from an operating system. An address of the memory storing the data is provided.

Abstract: A system and method of logless atomic data movement. An internal transaction is started within a multi-level storage architecture, the internal transaction to merge data from the first level storage structure to the second level storage structure. Committed data is read from a first level storage structure of the multi-level storage architecture as specified by the internal transaction. The committed data from the first level storage structure is inserted into a second level storage structure in a bulk insertion process, and the committed data is marked as being deleted from the first level storage. The internal transaction is then committed to the multi-level storage architecture when the committed data has been inserted into the second level storage structure.