Abstract: Techniques are provided for creating dynamic connections to objects on remote database clusters. Service-to-instance mapping information is provided to a listener process for a cluster database. The service-to-instance mapping indicates the current provider instance(s) of each object within the cluster database. To establish a connection to a remote object, a sending process uses an object link. The object link identifies the desired destination object, but not the provider instance of the object. The object link also contains a authentication information and other connection information that exists in regular database links. The global listener for the cluster database uses the service-to-instance mapping to determine which instance is the current provider of the specified object, and dynamically distinguishes the appropriate database instance as the endpoint of the connection.

Abstract: A method and system for implementing an improved access interface infrastructure is disclosed. In one approach, an access interface methods is directly supported by an application. The directly supported access interface method corresponds to an access interface implementation. Other access interface methods are transparently processed by being converted or mapped into a generic interface format, which is then translated into the directly supported format.

Abstract: A method and apparatus for managing sessions across the nodes of a multi-node system is provided. When a session is first initiated on any node of a multi-node system, a global session identifier is assigned to the session. The global session identifier uniquely identifies the session relative to all other sessions managed by the multi-node system. A session monitor may use the global session identifier to collect and store cumulative statistics about the activity of the session, regardless of which node of the multi-node system is currently managing the session, since the global session identifier uniquely identifies the session relative to all other sessions managed by the multi-node system. As a session may be uniquely identified across the lifetime of the session, the session state may be cleaned-up when the session ceases to be maintained, and the activity of the session during its lifetime may be analyzed.

Abstract: A system and method for facilitating a remote procedure call (RPC) using an auto-evolvable RPC interface or record type (an “RPC structure”). Each field of an auto-evolvable RPC structure includes a version number and a default value. During a negotiation process, a client and a server exchange their highest version numbers, thereby indicating their RPC capabilities to each other. A higher or more recent version number may indicate a more recent release of the application comprising the RPC. During an RPC, when the client sends a structure to the server, or vice versa, and it has a more recent version, it may omit one or more fields that are not in the recipient's version. When the server receives a structure from the client, or vice versa, and it has a more recent version, it may populate an extra field (not in the sender's version) with its default value.

Abstract: Various embodiments of the invention provide solutions to allow more sophisticated management of the relationship between a database and its clients (which can be, inter alia, end users, business applications, etc.). Merely by way of example, some embodiments can facilitate the management of work requests in a database, as well as the management of the quality-of-service in a database system. In some embodiments, an identification handle may be assigned to a database work request. A database management application can use the identification handle to identify the work request, as well, perhaps, as any related work requests. The identification handle may also identify the database (and/or an instance thereof) and/or a clustered database node, and the identification handle may be transmitted to a mid-tier application, e.g., to notify the mid-tier about the processing of the work request, changes in quality-of service, server availability, etc.

Abstract: A system, method, computer program and system for suspending a result set and continuing from a suspended result set for a cursor is disclosed. The rows from a row source corresponding to the cursor result set are suspended into storage so that when a fetch is requested the data can be sent (continued) from the suspended storage and does not depend on the original cursor row source or session to be available.

Abstract: A system, method, computer program and system for suspending a result set and continuing from a suspended result set for a scrollable cursor is disclosed. The rows from a row source corresponding to the scrollable cursor result set are suspended into storage so that when a fetch is requested the data can be sent (continued) from the suspended storage and does not depend on the original scrollable cursor row source or session to be available.

Abstract: A system, method, computer program and system for suspending a result set and continuing from a suspended result set for transparent session migration is disclosed. The rows from a row source are suspended into storage, so that after session migration, the client fetches can transparently continue from the suspended result set.

Abstract: A method and system for implementing scrollable cursors is described. A multi-tier caching structure is maintained, in which a partial result set is cached at the client computer and a more-complete result set is cached at the server computer. If the cursor is scrolled in either the forward or backward directions, the partial result set cached at the client computer is first checked to see if requested data is present. If so, then the requested data is fetched from the client cache and the current position of the cursor is moved to the appropriate position in the result set. If the requested data is not present in the client cache, then those data items are fetched from the cache at the server computer.

Abstract: A method for asynchronously notifying an application client of a system or data event of interest within a database includes steps of receiving a subscription to an event name from a logical agent, the event name corresponding to the event of interest, and receiving a registration from the application client, the registration including delivery information indicating at least where and how a notification concerning the event is to be delivered. The occurrence of the event is then detected within the database, whereupon the notification of the detected event is published to a data structure referenced by the event name. The delivery information is then retrieved and the published notification is formatted according to the retrieved delivery information. The formatted notification is then asynchronously delivered to the application client over a network, such as the Internet. The application client may specify a rule, the satisfaction of which is a precondition to the delivery of the notification.

Abstract: An approach migrates database sessions from a database server on which performance and resource availability requirements are not being met to another database server. Because workload is removed from the database server not meeting these requirements, improved performance there is promoted. Furthermore, the approach switches the users in a way that attempts to keep performance and resource availability levels at the database server receiving the database sessions within goals for performance and resource availability.

Abstract: Approaches are used for efficiently and effectively managing the dynamic allocation of resources of multi-node database systems between services provided by the multi-node database server. A service is a category of work that is hosted on the database server. The approaches manage allocation of resources at different levels. For services that use a particular database, the performance realized by the services is monitored. Resources assigned to the database are allocated between these services to ensure performance goals for each are met. Resources assigned to a cluster of nodes are allocated between the databases to ensure that performance goals for all the services that use the databases are met. Resources assigned to a farm of clusters are assigned amongst clusters based on service level agreements and back-end policies. The approach uses a hierarchy of directors to manage resources at the different levels.

Abstract: An approach provides for recovery of message driven directors responsible for dynamically allocating resources within a multi-node database system. The receipt of a message, the action taken in response to it, and other messages sent in furtherance of the action, are performed within a single transaction. In this way, the messages and other data are left in a state consistent with the message and action taken in response being fully processed or not processed at all. A standby director, stepping in for a crashed director, inherits a state consistent with where a crashed director last successfully completed an action. The approach insulates directors from the special perils of performing high latency actions by delegating the performance of such actions to a job, (i.e. another process).

Abstract: An approach efficiently and dynamically allocates and de-allocates database instances and nodes between databases. The approach performs this function in a way that accounts for the users of and services hosted by multiple databases.

Abstract: An approach generates performance grades. A performance grade is a value or set of values that indicates the relative work performance offered by a resource, such as a server in a multi-node system, relative to other resources. Performance grades are used to dynamically allocate work within a multi-node computer system. For example, performance grades are used for connection-time balancing, and to direct a database connection request to a multi-node database instance that a performance grade indicates provides better performance. Performance grade deltas are generated that reflect the incremental change in performance grade for additional sessions or work. Performance deltas are used to direct incoming sessions, to more optimally balance workload, and to deal with logon storms where a large number of connect requests arrive in a very short time period.

Abstract: An approach efficiently and dynamically places services within a multi-node system when expanding or contracting services, that is, increasing and decreasing the number of instances that host a service. Service placement decisions are made in a way that accounts for performance and availability requirements of both the service being placed and other services.

Abstract: A method and apparatus for asynchronously storing transaction information related to a transaction is provided. A client process executing on a client may initiate a transaction request with a server. The server processes the transaction, commits the transaction, and writes transaction information associated with the transaction to memory without durably storing the transaction information. Thereafter, the server processes processing the transaction returns a message to the client that the transaction has been committed. The server process may be reassigned to commit new work. Additional information that may be useful for the client about the result of the transaction may be contained in the message. Next, transaction information stored in memory is durably stored. A log writer may be used to durably store the transaction information to a log file. The client is subsequently notified that the transaction information has been durably stored at a client listening process.

Abstract: Direct memory accessed is used to perform database operations between two or more machines. A first segment of memory is allocated for a second machine, where at least one of the first machine and second machine is a database server. During performance of a database operation that involves the transfer of data from the second machine to the first machine, data in the first segment of memory is buffered in response to the second machine writing the data to a second segment of memory on the second machine.

Abstract: One embodiment of the present invention provides a system that modifies a function defined within an application programming interface (API) so that the function includes additional code. The system receives an additional code module to be integrated into the function within the API. The system also receives a command to integrate the additional code module into the function. This command is received through a pre-defined function within the API for integrating additional code into functions within the API. In response to the command, the system links the additional code into the function so that the additional code module is executed when the function is called. In one embodiment of the present invention, linking the additional code module into the function involves linking the additional code module as an entry function that is executed at the beginning of the function.

Abstract: An improved method, mechanism, and system for implementing, generating, and maintaining for implementing session pools is disclosed. Disclosed is a method, mechanism, and system for dynamic sizing of session pools, in which the number of sessions in a given session pool or sub-session pool can be dynamically adjusted upwards or downwards. Also disclosed is an approach for customizing a session in a session pool with a specific set of affinities and attributes, in which tags can be associated with the customized sessions. Tagging can be used to identify sessions to deallocate/reallocate to dynamically size the session or sub-session pools.