Abstract: An exemplary database management device includes a database storage memory for storing database information. A user access memory at least temporarily stores information to be included in the database. At least a portion of the user access memory is configured to operate as a database manager that allows a user to indicate an intended change to the database information. The database manager places the intended change into the user access memory and determines whether the intended change complies with a criterion responsive to the user attempting to implement the intended change. The database manager makes the intended change to the database information in the database storage memory if the intended change complies with the criterion. The database manager provides an indication that the intended change will not be made to the database and the database storage memory if the intended change does not comply with the criterion.

Abstract: The information receiving apparatus includes the related information receiving portion to receive content-related information, the mode selecting portion to select a link condition between the content and the related information, the related information request transmitting portion to transmit content designation information when the link condition is switched to the link mode or the content is switched in the link mode, and the display control portion to display the content, related information and link condition. The information providing apparatus includes the related information storage portion to store the related information associating with the content, the related information request receiving portion to receive the content designation information, the related information extracting portion to extract the related information corresponding to the content, and the related information transmitting portion to transmit the related information.

Abstract: Systems and methods for managing database transactions communicated from a browser-based software application to a database by a database management system in order to avoid or ameliorate transaction latency. According to one embodiment, the system or method comprises foreground and background processes, each generating database transactions. The foreground processes can submit an unlimited number of transactions to the database while background processes can only submit a limited, predetermined number of transactions to the database. To accomplish this, the background processes are associated with an in-memory queue of transactions that are then submitted to the database in a quantity no greater than the predetermined number. As a result, the database transactions sent by the foreground process will not have to wait behind more than the predetermined number of background transactions, thereby resulting in lower latency and avoiding or ameliorating delays to the user.

Abstract: An approach for sharing data between a calling application and a callee application is presented. A callee application receives a request for processing data owned and stored by the calling application in a data table. The callee application receives a document to which containers that include data elements from the data table are attached in a predefined order. The callee application identifies element types corresponding to the containers based on a mapping interface table. The callee application unloads data elements from the containers into a data store via the predefined order and associates the data elements with the corresponding element types. The callee application processes the data according to the request. The processing includes applying a business rule to a data element based on the business rule being associated with an element type of the data element. Only the callee application has knowledge of the applied business rule.

Abstract: Techniques to perform in-database computational programming. In one embodiment, for example, an apparatus may comprise a processor circuit and a client application operative on the processor circuit to generate a general request to perform an analytical calculation on data stored in a distributed database system based on a compute model, where the client application uses a threaded kernel service layer. The apparatus may also comprise a compute request component operative on the processor circuit to convert the general request to a compute request having a request format used by the distributed database system, and send the compute request to a node of the distributed database system having an analytic container. Other embodiments are described and claimed.

Abstract: A method for accessing a database is disclosed, which includes: receiving a modification operation request for shared data in the database which is mapped into a process address space; decomposing the modification operation request to a preset number of atomic operation sequences; invoking atomic operation interfaces according to an execution order of the various atomic operation sequences; and accessing the shared data in the database, which is mapped into the process address space, through atomic operations which are provided by the atomic operation interfaces. An apparatus for accessing a database and a database application system are also disclosed.

Abstract: A system, method, and non-transitory computer readable medium for providing controlled lock violation for data transactions are presented. The system includes a processor for executing a first data transaction and a second data transaction, the first and second data transactions operating on a plurality of data resources. A controlled lock violation module grants to the second transaction a conflicting lock to a data resource locked by the first transaction with a lock, the conflicting lock granted to the second transaction while the first transaction holds its lock. The controlled lock violation module can be applied to distributed transactions in a two-phase commit and to canned transactions.

Abstract: Systems, methods, and products for database system transaction management are provided herein. One aspect provides for annotating via a computing device at least one data object residing on the computing device utilizing at least one transaction tag, the at least one transaction tag being configured to indicate a status of an associated data object; processing at least one database transaction utilizing a transactional memory process, wherein access to the at least one data object is determined based on the status of the at least one data object; and updating the status of the at least one data object responsive to an attempted access of the at least one data object by the at least one database transaction. Other embodiments and aspects are also described herein.

Abstract: Methods, systems and computer programs are provided for processing data in a web service environment. In accordance with one embodiment, a data processing method is provided that comprises: entering data values into respective data entry fields of an electronic data entry form of a first computer; entering an identifier of a web service into the first computer; initiating a data processing stage to be performed by a second computer on the basis of the data values entered into the electronic data entry form by the first computer; sending signalling data for signalling initiation of the data processing stage to a web service; and sending a result of the data processing stage to a third computer, the third computer being coupled to the web service.

Abstract: A method and apparatus are described for sharing a session to access a database. A database server receives, in a session, a session context identifier and a command. The session context identifier identifies a session context to use for the session. The session context is a set of information or commands that plug into a session state and specify how commands in the session are to be performed for a particular user or privilege level. In response to receiving the identifier, the database server associates the session context with the database session for the connection. The database server uses the session context to process the command. The session context may then be detached from the session, allowing another user to attach to the session via another session context.

Abstract: A system and method can support application interoperation in a transactional middleware environment. A first transaction server operates to initiate a global transaction, wherein the first transaction server that is associated with a first format identifier (ID), and wherein the global transaction includes a plurality of branches and each said branch is associated with an individual branch qualifier. Furthermore, the first transaction server can direct at least one branch of the global transaction from the first transaction server to a second transactional server, wherein each said transactional server is associated with a second format identifier (ID), and configure a plurality of branches in the global transaction to share a common format identifier (ID).

Abstract: A computer-implementable method for protecting the integrity of dependent multi-tiered transactions is disclosed. The method includes a first application calling a transaction coordinator for the multi-tiered transaction, requesting initialization of a universal transaction context and the transaction coordinator starting a universal transaction composed of at least two component transactions by initializing the universal transaction context and returning a universal transaction identifier to the first application. The first application sending the universal transaction identifier to a second application, the second application committing a first transaction and a third application committing a second transaction depending on the first transaction. The integrity of the dependent transaction is protected by, in response to a failure of the second transaction, rolling back the second transaction and performing an atomic coordinated rollback of the first transaction.

Abstract: Handling garbage collection and exceptions in hardware assisted transactions. Embodiments are practiced in a computing environment including a hardware assisted transaction system. A method includes beginning a hardware assisted transaction, raising an exception while in the hardware assisted transaction, including creating an exception object, determining that the transaction should be rolled back, and as a result of determining that the transaction should be rolled back, marshaling the exception object out of the hardware assisted transaction.

Abstract: Example systems and methods of managing product genealogy data across distributed systems are described. In one implementation, a method identifies a material associated with a product that is part of a product batch. Usage information associated with the material is accessed, and a handling unit associated with the product batch is identified. Delivery information associated with the product batch is also accessed. A genealogy is generated for the product batch based on the material, the usage information, the handling unit, and the delivery information.

Abstract: Writing data in a distributed database having a plurality of nodes is disclosed. Writing includes receiving a write request at a node, wherein the write request is associated with one or more operations to define an atomic transaction and performing the atomic transaction based on the request. The atomic transaction includes writing to a first version of the database in the node and writing to an entity representative of a state of the first version of the database.

Abstract: A method begins with receiving an indication that one of a plurality of merchant data files includes an inconsistency with respect to a corresponding merchant profile record in a merchant profile database. The merchant data file of the plurality of merchant data files includes merchant name, merchant business address, and merchant business information. The method continues with receiving a request to authenticate the updating of the corresponding merchant profile record when the inconsistency for the one of the plurality of merchant data files is addressed by a merchant device updating the corresponding merchant profile record. The merchant device corresponds to a merchant of the one of the plurality of merchant data files. The method continues with providing an authentication response regarding the updating of the corresponding merchant profile record.

Abstract: A first process in a data grid provides an initial version that corresponds to transaction data controlled by the first to a second process and a third process. The first process receives a request of the second process and changes the transaction data based on a first transaction. The first process provides a current version value of the transaction data to the second process and commit the change to the transaction data based on the first transaction if the current version value matches the initial version value provided to the second process and creates a new version value for the transaction data upon committing the change. The first process changes the transaction data based on the second transaction and rolls back the change made to the transaction data based on the second transaction if the new version value does not match the initial version value provided to the third process.

Abstract: A first process executing in a computer system in a data grid receives a request to perform at least one transaction operation of a transaction based on remote transaction data of at least one other process in the data grid. The at least one other process is capable to perform a prepare operation for a transaction. The first process identifies a local copy of the remote transaction data in a local data structure and performs the at least one transaction operation using the local copy of the remote transaction data without acquiring a lock on the remote transaction data.

Abstract: Embodiments of the invention provide systems and methods for providing summarizations of data and transactions based on the status of the summarization and the data and transactions being summarized. According to one embodiment, a method for providing summarizations of data and transactions related to one or more applications can comprise initiating a first summarization of the data and transactions related to the one or more applications. The first summarization can be paused in response to a request to evaluate the data and transactions being summarized. Data and transactions available for summarization can be evaluated in response to and based on the request. The first summarization can be resumed upon a completion or a timeout of the evaluating of the data and transactions being summarized.

Abstract: A method for validating SRS registry transaction data includes receiving OLTP transaction data from a first database, parsing the OLTP transaction data, and comparing the parsed OLTP transaction data to one or more of a set of profiles. Each of the one or more of the set of profiles includes metadata in XML files. The method also includes caching the parsed OLTP transaction data in a first data cache, receiving log data associated with the OLTP transaction data; and caching the log data in a second data cache. The method further includes correlating the parsed transaction data cached in the first data cache with the log data cached in the second data cache.

Abstract: Logging for an identified asset is coordinated when provided by applications implemented on multiple network elements. An indicator is set, prior to activity occurring related to the asset, to log information for the asset based on specified criteria. A first application implemented on a first network element generates, based on the indicator, a first detailed log for activity occurring related to the asset. A representation of the asset is passed to a downstream application implemented on a second network element. A second detailed log for activity occurring related to the asset is generated by the downstream application based on the indicator. The first detailed log is correlated with the second detailed log.

Abstract: A lower-level master node sends, to a higher-level master node, a write set expanded in its own memory including a shadow copy of its own database and a heap tuple map, and the higher-level master node that received the write set verifies whether the update has already been executed and sends the record of this update to the lower-level master node as a transaction log, whereby the database can be updated efficiently and consistently from the lower-level master node to the higher-level master node, and from the higher-level master node to the lower-level master node under its control.

Abstract: A database comprises a database interface and a database updater. The database interface receives a first set of information and a second set of information to be updated in the database. The database updater updates a second set of information in the database based at least in part on a condition that a first set of information in the database has been previously updated.

Abstract: Disclosed are an XML document management method for cancelling a specific past operation, and a system using the same. The method comprises identifying an original operation to be cancelled, identifying an XML resource to be cancelled, identifying a previous value of the XML resource to be cancelled, identifying a next value of the XML resource to be cancelled, configuring a cancel operation, and applying the cancel operation to the XML resource to be cancelled.

Abstract: A method for performing I/O operations on a file stored in a file system utilizing a shared data storage system and accessible by a plurality of host computers is disclosed. A host computer receives from a process executing on it, a request to read data stored in the file. The host computer then requests the data stored in the file without acquiring a lock from the file system. The host computer also maintains a timeout value associated with the file while reading the data. The host computer receives at least a portion of the data prior to an expiration of time, and if all the data has not been received before the expiration of time, it then assesses whether another of the host computers has acquired a lock on the file, and, if so, invalidates the received data without providing it to the requesting process.

Abstract: Systems and methods are provided for providing an automated validity check of transaction data postings. In one implementation, a method is provided that includes entering at least one code for specifying at least one posting to be performed for a transactional data processing operation. The method may also include starting the transactional data processing operation, sending a request to a service component for performing a validity check of the at least one code, buffering one or more posting requests resulting from execution of the transactional data processing operation. Further, the method may include sending, in response to receipt of a first signal indicative of code validity from the service component, the one or more buffered posting requests with the at least one code to a posting component.

Abstract: A database system that issues a reference transaction by designating a time stamp. Data structures are provided for making an inquiry about the latest value at a designated time using a database in which values and information on times associated with the individual values are contained in a table. One of the data structures includes, for each of IDs associated with the values in the database, at least one time stamp that is sorted in chronological order (hereinafter referred to as a first time stamp); values belonging to the individual first time stamps; and a pointer that designates one of the first time stamps, the first time stamps indicating the times when the values become valid. The other of the data structures includes, for each of the IDs, the designated first time stamp and a value belonging to the designated first time stamp.

Abstract: A lower-level master node sends, to a higher-level master node, a write set expanded in its own memory including a shadow copy of its own database and a heap tuple map, and the higher-level master node that received the write set verifies whether the update has already been executed and sends the record of this update to the lower-level master node as a transaction log, whereby the database can be updated efficiently and consistently from the lower-level master node to the higher-level master node, and from the higher-level master node to the lower-level master node under its control.

Abstract: A lower-level master node sends, to a higher-level master node, a write set expanded in its own memory including a shadow copy of its own database and a heap_tuple map, and the higher-level master node that received the write set verifies whether the update has already been executed and sends the record of this update to the lower-level master node as a transaction log, whereby the database can be updated efficiently and consistently from the lower-level master node to the higher-level master node, and from the higher-level master node to the lower-level master node under its control.

Abstract: Various technologies and techniques are described for providing a transaction grouping feature for use in programs operating under a transactional memory system. The transaction grouping feature is operable to allow transaction groups to be created that contain related transactions. The transaction groups are used to enhance performance and/or operation of the programs. Different locking and versioning mechanisms can be used with different transaction groups. When running transactions, a hardware transactional memory execution mechanism can be used for one transaction group while a software transactional memory execution mechanism used for another transaction group.

Abstract: Methods and systems are provided for determining a person that matches a user request. A user request may be received that includes identification information at least partially identifying a person other than the requesting user, the request including a name of the person. Personal information regarding the requesting user and validated personal information regarding individuals potentially matching the request may be retrieved. A score may then be determined for each potentially matching individual, where the score is determined by comparing the personal information regarding the requesting user and the validated personal information regarding the given individual. A matching individual may then be determined based on the determined scores.

Abstract: Embodiments include a method, apparatus and computer program product for executing a database transaction in parallel using subtransactions. The method includes receiving a transaction at an application, the transaction having a first statement and a second statement, and determining whether operation of the first statement is independent from operation of the second statement. When it is determined that operation of the first statement is independent from operation of the second statement, assigning the first statement to a first subtransaction and the second statement to a second subtransaction, the first and second subtransactions being part of a transaction group. The method further includes executing the subtransactions using resources of the database. Finally, when execution of all of the subtransactions have successfully completed, committing all of the subtransactions.

Abstract: Provided are a method, system and program for batching transactions to apply to a database. A transaction manager receives a plurality of transactions to apply to a database and adds the transactions to a work queue. One of a plurality of agents processes a batch of transactions from the work queue. Each agent executes a batch of transactions from the work queue against the database independent of the operations of other of the agents executing batches of transactions. The agent applies the transactions in the batch against the database and commits the transactions in the batch to the database in response to completing all of the transactions.

Abstract: A system for managing transactions, including a first reference cell associated with a starting value for a first variable, a first thread having an outer atomic transaction including a first instruction to write a first value to the first variable, a second thread, executing in parallel with the first thread, having an inner atomic transaction including a second instruction to write a second value to the first variable, where the inner atomic transaction is nested within the outer atomic transaction, a first value node created by the outer atomic transaction and storing the first value in response to execution of the first instruction, and a second value node created by the inner atomic transaction, storing the second value in response to execution of the second instruction, and having a previous node pointer referencing the first value node.

Abstract: In accordance with embodiments, there are provided techniques for implementing batch processing in a multi-tenant database system. These techniques for implementing batch processing in a multi-tenant database system may enable embodiments to provide great flexibility to a tenant of the architecture to perform desired functions on content of the database while allowing the owner of the architecture schedule the processing of the functions on the content.

Abstract: An insertion of a record into a table that includes a primary key column and a second column that includes a global uniqueness constraint across all of a plurality of data partitions across which the table is split is initiated without checking that a value of the record in the second column is globally unique by contacting other partitions the one partition to which the record is to be added to. The insertion can be processed, at least in part by implementing a write lock on the one partition but without implementing a read lock on the other partitions. The write lock on the one partition can be released after the insertion is completed, after which the validity of the insertion can be verified, for example by examining the other parts and a delta partition corresponding to the table. The insertion can be undone if the insertion was not valid.

Abstract: A data grid node that is hosted by a computing system receives a request to prepare transaction operations for a multi-operational transaction for a commit. The transaction operations are associated with other data grid nodes in the data grid. The data grid node stores transaction state data for the multi-operational transaction in local memory associated with the data grid node and identifies other data grid nodes in the data grid that manage the data pertaining to the transaction operations for the multi-operational transaction. The data grid node sends the transaction state data to the other data grid nodes and the other data grid nodes store the transaction state data in local memory associated with the corresponding data grid node.

Abstract: A system includes an application programming interface (API) configured to process a transaction request that specifies data content located at a storage medium. A request processor associated with the API can be configured to determine a delivery format for the data content in response to the transaction request. A file converter can be configured to transform the data content into the delivery format in accordance with the transaction request.

Abstract: A distributed database transaction coordination manager's outcome store may be unavailable to resolve in-doubt transactions locally, e.g., after an unclean detach, during an outcomes store restore, or during a logical database restore. To facilitate transactional consistency, AGEs and values based on them are used. Some code avoids reformatting any closed physical portion for reuse based on the segment's most recently received minimum of persisted AGEs. Some code commits any in-doubt transactions that appear on an aggregate list and aborts any not on the aggregate list. Some code writes each segment's transaction commit records to persistent storage until the segment's persisted-AGE is not less than a common-restore-AGE, and some code resolves any in-doubt transactions based on a harvested outcomes list. Outcomes may reside in a log or a persisted transactions table. A restore checkpoint may include harvested outcomes. Segments may reside on cloud nodes and/or in a shared nothing database system.

Abstract: In a light-weight transactional system architecture, each component providing a service performs its own scheduling and transaction management. An invocation of one of these services (through remote method invocation) results in the creation of a local transaction (child of the invoking transaction and parent of any transaction that might be triggered by invoking the services of other servers). The information that is required to build a global composite transaction is implicitly added by the system to each call. Each transaction is, however, independently handled at each server. That is, the servers neither communicate among themselves nor rely on a centralized component to make scheduling or recovery decisions. In this way, components can be dynamically added or removed from the system without compromising correctness. Regardless of the configuration, the system according to the invention guarantees that transactions executed over these servers are correct and recoverable at a global and local level.

Abstract: A method of performing transactions in accordance with fairness criteria is provided wherein one of a plurality of entities initiates a transaction on an object at a database. The steps or operations of the initiated transaction are immediately processed up to the transaction ownership step. Propagation delays are determined between the database and at least some of the other entities that are capable of initiating transactions to the database. The propagation delays and a fairness criteria is used to determine the fair propagation delay period. Upon determining that the fair propagation delay period has been exceeded, it is detecting whether any of the other entities initiated a transaction on the same object during the fair propagation delay time period. If not, then the transaction initiating entity performs the transaction ownership step on the initiated transaction.

Abstract: An interactive system, such as a webserver, is described of the type wherein responses to a user are associated with states of a state machine, the responses being generated as a result of a transition into a state associated with the response, the system comprising a state machine controller arranged to change states of the state machine according to the processing of user-initiated events. To provide for handling of concurrent events, the state machine controller is arranged, during processing of a current event, to determine whether the current event was initiated at an earlier time than another event and, if so, (i) restore the state machine to a condition consistent with that immediately prior to processing of the current event, and then (ii) carry out a state transition according the other event.

Abstract: Methods and systems are provided for synchronizing field values in transient data objects, such as JAVA® objects, before saving a transaction to a database. A dependency from one data object to another data object is detected, and changes which affect the second data object's fields through the dependency are flowed through to the second data object. This is performed between each step of a multistep save process, such between triggers, validation rules, workflows, and the final committing of data to the database.

Abstract: Provided is a computer system including a plurality of computing hosts, which constructs a shared file system dynamically so that job execution efficiency is improved. In the computer system which includes the plurality of computing hosts and executes a job requested, in a case where the job is executed by the plurality of computing hosts, each computing host which executes the job is configured to: share a file necessary for executing the job; access the shared file to execute the requested job; and cancel the sharing of the file after execution of the requested job is completed.

Abstract: A system and method may include receiving an order and an error identifier, indexing a database based on the error identifier to identify a rule identifier, and indexing the database based on the rule identifier to identify a rule. The system and method may further include applying the rule to modify the order to generate a modified order, and submitting the modified order for processing.

Abstract: A computer-implemented method, a computer-readable medium and a system are provided. A transaction master for each of a plurality of transactions of a database is provided. Each transaction master is configured to communicate with at least one transaction slave to manage execution of a transaction in the plurality of transactions. Each transaction master configured to perform generating a transaction token to specify data to be visible for a transaction on the database, the transaction token including a transaction identifier for identifying whether the transaction is a committed transaction or an uncommitted transaction, receiving a request to commit the transaction, initiating, based on the request, a two-phase commit operation to commit the transaction.

Abstract: In one embodiment, methods and systems for change management are described. A server system may include a physical server and a virtual server capable of being deployed on the physical server. A server change group may include one or more server change objects. Each server change object may represent a server change to be made to at least one of the physical server or the virtual server. A change manager may receive a request for a change to the server system, select transitioning change objects from among the server change objects to transition the server system from a current state to an expected state after implementation of the change, and execute the transitioning change objects to implement the change to the server system.

Abstract: A plurality of virtual files are instantiated in a columnar database. The columnar database includes a columnar data store that persists tables of data contained therein to the plurality of virtual files. Each virtual file is stored in physical data storage and a portion of the virtual file can be cached transiently in a persistence layer intermediate the columnar data store and the physical data storage. The virtual files each comprise a database object for storing data records. Operation are processed, in the columnar database, using the virtual files such that changes to virtual files resulting from the operations of one transaction are isolated from changes on the same virtual files resulting from the operations of other transactions. Related apparatus, systems, techniques and articles are also described.

Abstract: The embodiments herein provide a system and a method for integrating a data from a source to a destination. The method comprises generating a global-id, setting an event-id corresponding to an entity id in the global id, polling a data from a source, sorting changes of a source system based on a time of update and an entity id, creating and comparing an old as of state value and a new as of state value for each field for each update in the entity in the source and destination to detect a conflict on an entity, sending a time of update in the entity and a revision id of a change to the destination, comparing the global id with an event id for each entity at the destination to detect a presence of an entity in the destination and processing an entity at the destination based an event id.

Abstract: An embodiment provides a method for server replication and transaction commitment. The method includes receiving a transaction from a client node at one or more memory nodes, each memory node comprising a number of replicas, and determining, for each one of the replicas, whether the replica is able to commit the transaction. The method also includes sending a response from each of the replicas to a consensus node, wherein the consensus node is configured to record whether the response is a commit response. The method further includes committing the transaction if, at each memory node, a quorum of the replicas is able to commit the transaction, and aborting the transaction otherwise.