Abstract: In some example embodiments, a method comprises: receiving, by a first node of a plurality of nodes in a distributed database system on a shared disk cluster infrastructure, a transaction request to perform a user database transaction a data item in a user database on a shared disk; acquiring, by the first node, a transaction lock for the data item; storing a lock file for the user database transaction in a lock information database on the shared disk, the lock file comprising lock information for the transaction lock and an indication of a status of the user database transaction, and the lock information comprising an identification of a location of the data item; and storing a transaction record of the user database transaction in the user database on the shared disk subsequent to the storing of the lock file in the lock information database on the shared disk.

Abstract: An object-oriented synchronization pattern for synchronizing a mobile application and a corresponding enterprise application is provided herein. The synchronization pattern uses service invocations to convey application state differential from the mobile device to the enterprise server and object-based database synchronization for conveying application state differential from the enterprise to the mobile device. Service invocations may be conveyed in batch or individually separately and using a variety of service types.

Abstract: A method, a system and a computer program product for maintaining a pre-computed result set are disclosed. A server coupled to a data source determines whether an object stored in the data source received an update. The server identifies at least one identifier associated with a pre-computed result set based on that determination. The pre-computed result set is computed based on the object. The server computes an updated pre-computed result set using the identifier by applying the received update to the pre-computed result set.

Abstract: Systems, methods, computer program product embodiments are provided for locking retained resources of database information in a distributed shared disk cluster environment. An embodiment includes providing a request on demand for physical access to a page by a task of a node among a cluster of nodes, managing selective bypassing of waiting access requests to the page at intranode and internode levels in response to the request on demand, and handling requests for page ownership to prioritize a request on demand. Further included are determining whether another node holds a lock on the page and identifying an access type for the waiting access requests in order to coordinate transfer of the lock to the node.

Abstract: A method can include receiving a request to execute a database command identifying a target table; identifying a plurality of rows to insert into the target table based in part on the database command; writing rows, from the plurality of rows, into a data page until the data page is full; determining, by an index thread manager, a number of threads to use for updating indexes defined for the target table; and upon determining the data page is full, updating, in parallel, the indexes defined for the target table using the number of threads.

Abstract: Distributing work in a distributed computing environment that includes multiple nodes. An individual node can receive a work assignment, which can then be divided into a plurality of work units. A first work unit can then be distributed to a first worker node. At least a portion of the first work unit can be re-distributed to a second worker node in response to determining that the first worker node has experienced a failure condition with respect to the first work unit.

Abstract: System, method, computer program product embodiments and combinations and sub-combinations thereof for hybrid data replication are described. Aspects include identifying a type of database data replication, the type including a combination of replication approaches, and managing replication based on the identified type, including coordinated switching from one replication approach to another automatically with transactional consistency maintained among source and target databases.

Abstract: A method can include initiating execution of a database command, the database command associated with a base table with at least one row to copy to a target table, the database command associated with a non-bulk insert mode; making a run-time decision on whether to automatically convert the insert mode from the non-bulk insert mode to a BULK insert mode based on the number of row buffers filled with rows from the base table during execution of the database command; and inserting at least one row into the target table using an insert mode based on the run-time decision.

Abstract: A delta store giving row-level versioning semantics to a non-row-level versioning underlying store is described. An example method includes establishing a column-based in-memory database including a main store and a delta store, where the main store does not allow concurrent transactions on a same table and the delta store has a plurality of row-visibility bitmaps implementing a row-level versioning mechanism that allows concurrent transactions on the same table. A transaction associated with the column-based in-memory database is received. For each table read by the transaction, a version of the table in the delta store that represents a transaction-consistent snapshot of the database visible to the transaction is determined. Each table is represented in the main store and the delta store; and each version of the table is represented by one or more bitmaps.

Abstract: Enhanced shared memory based communication driver for improved performance and scalability is described. An example method includes creating a shared memory segment for a database server instance. The database server instance and a client reside on a same computing device. A first database connection is established to the database server instance using a pre-configured communication end point. An identifier of the shared memory segment for the database server instance is sent to the database server instance and the database server instance listens to subsequent connection requests generated on the shared memory segment. Moreover, a second database connection to the database server instance is established using the shared memory segment as a communication end point. Upon a successful connection of the second database connection, the first database connection is closed.

Abstract: Various embodiments of systems and methods for dynamically switching device configuration based upon context are described herein. In an aspect, the method includes reading a tag attached to an entry gate of a restricted area through a device. Upon reading the tag, an application is executed to connect the device to a mobile device management (MDM) server. Upon establishing the connection, the restricted area identifier (ID) is sent to the MDM server. The device receives one or more policies applicable for the restricted area from the MDM server. The received one or more policies are executed on the device to change the device configuration. After execution, the device sends a confirmation message to the MDM server to indicate that the device is policy complaint. Upon receiving the confirmation, the MDM server instructs to open the entry gate to allow the device within the restricted area.

Abstract: Disclosed herein are system, method, and computer program product embodiments for replicating data in a distributed database system. Data containing a replicated truncation point associated with a replicating system is received via a data path. It can then be determined that the truncation point represents the point at which all data in a transaction log has been replicated (e.g., successfully or safely) and the transaction log can then be truncated at the truncation point (i.e., the data up to the truncation point deflected). Data containing an additional replicated truncation point associated with an additional replicating system via an additional data path may be received. It can then be determined that the additional replicated truncation point represents the point at which all data in the transaction log has been replicated and the transaction log can be then truncated at the additional replicated truncation point.

Abstract: A method for inserting rows into a target table can include receiving a database command, the database command associated with a base table with at least one row to copy to a target table; receiving an indication that use of a BULK insert mode is feasible for the database command; based on the indication, and determining that an insert mode for the database command has been converted from a non-bulk insert mode to the BULK insert mode: reading a row from the base table; building the row read from the base table into an allocated row buffer; inserting the row into the target table in the BULK insert mode; and if it is determined that the allocated row buffer is full, updating at least one index in parallel with the inserting.

Abstract: A method and system for transforming a serial schedule of transactions into a parallel schedule of transaction is disclosed. In one example, a computer system stores a list of data transactions in a transaction log. The computer system then reads a respective data transaction from the transaction log. The computer system determines whether the respective data transaction is dependent on any other currently pending data transaction. In accordance with a determination that the respective data transaction is not dependent on any other currently pending data transaction, the computer system applies the data changes to a reconstructed data set. In accordance with a determination that the respective data transaction is dependent on a currently pending second data transaction, the computer system delays commitment of the respective data transaction until the second data transaction has been applied to the reconstructed data set.

Abstract: Disclosed herein are system, method, and computer program product embodiments for calibrating and using a stable storage model. An embodiment operates by generating, by a central computer, an access request for a stable storage, wherein the access request comprises a plurality of page accesses; measuring a cost to execute the access request on the stable storage; amortizing the cost over the plurality of page accesses; and calibrating, by the central computer, a stable storage model based on the amortized cost.

Abstract: Systems and methods are presented for load balancing databases in a cloud server environment. In some embodiments, a method can include accessing, by a server in a network-based system, one or more system configuration parameters of the network-based system, with the one or more system configuration parameters defining one or more performance capabilities of the network-based system. The method may also include accessing performance characteristics of a query of a queried database; generating a quadtree decomposition, with the quadtree decomposition modeling a cost estimate of the database query as a function of a range of the performance capabilities of the one or more system configuration parameters; and generating a proposed packing of databases based on the modeled cost estimate of the query including the queried database and defining a configuration of a plurality of databases to be stored in the server.

Abstract: Existing algorithms to build balanced tree structures (“b-trees”) compare a data element (e.g., a key) to be inserted with the data elements that have already been inserted to find the correct position to insert the data element. Additionally, the algorithms balance and/or rebalance the b-tree when any individual node gets over-filled. As part of this balancing, data elements stored in the various nodes are moved to other nodes. These operations can incur both time and resource costs. We propose an algorithm to build a b-tree in a bottom up manner and a technique to modify trees built using the aforementioned algorithm so that they are balanced. We also propose a method to allow for adding more data into the thus-built b-tree as long as it follows a certain set of pre-conditions.

Abstract: Synchronization of metadata structures in a multi-threaded system includes receiving, by a first thread of a processing device, a request for a metadata structure located in a first cache associated with an object, obtaining, by the first thread of the processing device, a synchronization mechanism associated with the first cache, holding, by the first thread of the processing device, the metadata structure associated with the object, receiving, by a second thread of the processing device, a request for the metadata structure in a second cache associated with the object, obtaining, by the second thread of the processing device, a synchronization mechanism associated with the second cache and informing the second thread of the processing device that the metadata structure associated with the object is not available.

Abstract: Systems, methods and computer program products for DDL replication are described herein. An embodiment includes a replication agent to instantiate one or more DDL triggers in a primary database and a replication server to provide DDL command text to a replicate database based on said DDL triggers. The replication agent uses the DDL trigger(s) to capture one or more DDL events and retrieve a transaction log associated with the DDL events. The replication agent processes the transaction log to obtain DDL command text. The DDL command text is then sent to a replicate database by the replication server where it is executed in an appropriate user context. In this way, DDL commands in may be replicated using DDL trigger(s) and session context switching.

Abstract: Dynamically directing a command to a node in a distributed database is described. An example method includes receiving the command from a client application to access data in the distributed database, where the command contains a set of parameters. A primary key is constructed from at least some of the parameters. The client further generates routing information from a node-partition table based on a comparison of the primary key with an entry in the node-partition table, where the node-partition table maps the primary key to a node in the distributed database. Accordingly, the command is directed to the node in the distributed database based on the routing information.