International Business Machines Corporation

Yang Lei

Li Feng Zhang

Xiaoqiao Meng

Jian Tan

Lawrence Scott Rich

Timothy Marc Francis

Timo J Salo

Teresa Chung Kan

Kevin Joe Williams

Arthur Thomas Jolin

Xin Zhao

Ronen Grosman

Soloman J Barghouthi

Thomas Bitonti

Adrian Chan

Hasan Muhammad

Dai Bin

Chen Y Yu

A dialing method for a calling party includes determining a plurality of phone number groups to be dialed in a simultaneous or sequential ringing mode, each of the groups including at least one phone number; and transmitting the plurality of phone number groups and a dialing flag to a calling server. The dialing flag including a simultaneous or sequential ringing flag indicating that the plurality of phone number groups are to be dialed in the simultaneous or sequential ringing mode. The calling party can freely custom multiple phone numbers expected to be rung simultaneously or sequentially and transmit them to a calling server, without registering in the calling server in advance. Thus, the trouble of the user registering the numbers in the calling server may be avoided and the calling server does not need to maintain a large-scale database for storing the multiple numbers at a large cost.

Dialing method and device

Inducing perturbation by varying a supply amount of the resource type in the system and measuring performance of the software entity at multiple variation levels of the supply amount of the resource type in the system. A model may be built that characterizes a relationship between the measured performance and the variation levels. The model may be applied to detect the resource bottleneck. The model may be also applied for capacity planning.

Method to apply perturbation for resource bottleneck detection and capacity planning

Embodiments of the present invention address deficiencies of the art in respect to programmatic database access and provide a method, system and computer program product for programmatic partial updating of a row. In one embodiment, a data processing system for programmatic partial updating of a row in a database can include a database proxy driver configured to expose an interface for interacting with the database and to accept an execution of a prepared statement without requiring set values for all fields bound by the prepared statement. The interface can include, for example, a Java Database Connectivity (JDBC) compliant interface. The prepared statement can include a binding to multiple fields in a designated row and a set of setter methods defined for a subset of the multiple fields.

Partial updating in a database proxy driver

A method, an apparatus, and computer instructions are provided for a context based cache infrastructure to enable subset query over a cached object. Responsive to detecting a query to a root context of a context tree, the tree is traversed for a parent context of a subcontext corresponding to the name and value pair, which is identified by a user in the query. If the parent context caches all query results, the query results are iterated and the remaining name and value pairs are filtered out. However, if the parent context does not cache all query results, the traversing step is repeated for next parent context of the subcontext until a root context is encountered. If a root context is encountered, a query is issued to the database for the name and value pair and the result of the database query is cached in a new context.

Context based cache infrastructure to enable subset query over a cached object

Methods, apparatus and computer instructions for a container managed persistent support architecture that meets the Enterprise Java Bean (EJB) Specification are disclosed. The support architecture provides application programmers a model for balancing generated components with runtime code to better optimize flexibility and efficiency of applications. Six generated components: concrete bean, bean adaptor binding, injector, extractor, data cache entry and function set, are used in combination with runtime code to perform typical operations of CMP entity beans.

Method and apparatus for a container managed persistent entity bean support architecture

The present invention comprises a process for managing entity-relationship data for data objects persisted in a relational database. In particular, the process minimizes the number of database operations needed to maintain persistent referential integrity between data objects, thereby minimizing the number of times that a program accesses the database. In the preferred embodiment, the inventive process is implemented as an improved container program having a CMR engine that controls the persistence of data object relationships in a relational database. The improved container program comprises one or more referential integrity rules, which control the container program's response to a client object program's instructions that affect entity-relationship data.

Managing entity-relationship data for data objects persisted in a relational database

A method, system, and computer program product for reducing dependency calculation time in object persistence with circular referential integrity dependency is provided. The method includes building a graph using foreign key dependency from object to relational mapping, where nodes of the graph are object types and connected directionally from a source containing a foreign key to a target of a foreign key reference. The method further includes topologically sorting the graph to order dependencies among the nodes including circular dependences. The method also includes encapsulating the circular dependencies as a complex node. Furthermore, the method includes performing object dependency calculations on the nodes and the complex node in the graph. The results of the object dependency calculations are used to generate a sequence in which the objects can be modified in a relational database.

Methods, systems, and computer program products for using graphs to solve circular dependency in object persistence

The invention controls the persistence of server component objects during a transaction, thereby minimizing the number of times that a program accesses a database. The invention also minimizes the number of operations needed. The invention caches the database operations required to persist server component objects until a client object program commits the transaction or until the program needs to access the server component objects. The invention comprises an improved container program that creates server component objects, associates each server component object with a transaction, maintains the server component objects in a cache, filters out unnecessary database operations and then flushes the cache at the appropriate time so that a server component object is persisted only when a client program commits an associated transaction or another object attempts to access the server component object.

Defer container-managed persistence operations on transactional objects

The present invention provides methods, apparatus and computer instructions for a container managed persistent support architecture that meets the Enterprise Java Bean (EJB) Specification. The support architecture provides application programmers a model for balancing generated components with runtime code to better optimize flexibility and efficiency of applications. Six generated components: concrete bean, bean adaptor binding, injector, extractor, data cache entry and function set, are used in combination with runtime code to perform typical operations of CMP entity beans.

An apparatus and method enable batch processing of database updates without modifying generated code, i.e., without redeployment of the application server or application. A batch mechanism intercepts calls from the generated code, compiles updates into batches, and processes the updates to the database in batches. In this manner the batch mechanism takes advantage of the batch processing capabilities of the database without modifying the generated code.

Growing community of inventors

Cary, NC, United States of America

Yang Lei