Abstract:
A system and method for transparent multi key-value weighted attributed connection using uni-tag connection pools. In accordance with an embodiment, a connection pool enables labeling of connections that software applications can use to access a database. A connection pool associated with a database enables tagging of connection pools at the database and allows applications to selectively obtain connections based on tags. A request is received from an application to query data from the database using a labeled connection or low-cost alternative. If a low-cost connection is found, but requires configuration, the system returns unmatched labels for use by the application in configuring its environment to use the connection. The system can also generate a tag for the connection. Upon subsequent release of the database session, the tag can be made available for subsequent use of the tag, or a tagged connection, by the same or by other applications.
Abstract:
In accordance with an embodiment, a system enables multidimensional search within a resource pool, to support complex borrow operations such as, for example, specifying ranges for particular connection properties. As threads access the pool, attempting to borrow connections having particular connection properties, one or more skipped pool elements can be represented as skip lists within a k-dimensional tree (KD-tree) or other data structure that enables searching across multiple dimensions. In response to receiving a request to borrow a connection having particular connection properties, a multidimensional search can be performed within the KD-tree to determine the availability of a connection having the requested properties.
Abstract:
In accordance with an embodiment, described herein is a system and method for row buffering in a database environment. A transparency engine can be provided between client applications and a database, and can operate as a proxy engine for the database and as a session abstraction layer for the client applications, to enable the client applications to utilize database features provided by the connection pool without code changes to the client applications. The transparency engine can maintain a plurality of local row buffers to store rows fetched from a database. The local buffers can be filled by rows pre-fetched from the database. When a client application requests rows from the database, the transparency engine can first check whether the rows exist in a local buffer. If the rows are present in the local buffer, the transparency engine sends the rows to the requesting client application, without going to the database.
Abstract:
In accordance with an embodiment, described herein is a system and method for high availability and load balancing in a database environment. A transparency engine can be provided between client applications and a database, and can operate as a proxy engine for the database and as a session abstraction layer for the client applications, to enable the client applications to utilize database features provided by the connection pool without code changes to the client applications. The transparency can keep track of session states, request boundaries and cursors to efficiently reuse the database connections across the client applications. The transparency engine can use the request boundaries and indicators from the database to detect safe places to drain database connections in the event of database outages.
Abstract:
A system and method for reducing communications overhead in a distributed transaction processing environment such as an XA environment. In accordance with an embodiment communication overhead is reduced in a transaction by deferring a transaction end communication. The deferred transaction end communication is determined from a subsequent XA transaction communication thereby reducing the number of networks calls required for each transaction and enhancing system performance.
Abstract:
A system and method for a planned migration of service connections from a first database instance to a second database instance in a clustered database. In accordance with an embodiment, a data source and connection pool enable access by a software application to a service on the first database instance. The data source is associated with a parameter specifying a delay-for-planned-draining, and a parameter specifying a planned-draining-period, which are used to rebalance connections when relocating a service. When a service is stopped on the first database instance, the connection pool receives a “service down” event from a notification service, and maintains the connections up to a time corresponding to the delay-for-planned-draining. When a “service up” event is received, the connection pool spreads migration of the connections from the first to second database instance over the planned-draining-period.
Abstract:
Transactional and non-transactional data for maintaining session state is described. In a session, a server instance receives, from a client, a request to execute transactional commands and non-transactional commands. The server instance sends at least one first directive executable at the client to store, in a first set of information, one or more first items representing one or more particular transactional commands that are open but not yet committed. The first set of information is maintained separately from a second set of information including one or more second items representing one or more particular non-transactional commands that have been processed. Based on committing one or more particular transactional commands, the server instance sends at least one second directive executable at the client to purge, from the first set of information, the one or more first items without purging, from the second set of information, the one or more second items.
Abstract:
Described herein are systems and methods for providing access to a database in a multi-tenant environment, including the use of a connection pool, and support for server-side connection pool multiple tagging. For example, the system can provide a capability to associate multiple connection properties with a particular server-side connection in, e.g., an Oracle Database Resident Connection Pooling (DRCP) environment; look up a connection with one or multiple properties; and provide information about a returned connection so that a requesting application can review the properties associated with the returned connection, in order to determine how best to “fix-up” or otherwise use that connection.
Abstract:
Described herein are systems and methods for providing access to a database in a multi-tenant environment, including the use of a connection pool, and support for live addition of a tenant. When a pluggable database (PDB), for use by a tenant, is added to a multi-tenant database, it can generate an event to notify the connection pool. The connection pool environment consumes this PDB-add event, and dynamically configures a new tenant to access the shared pool. Since the new tenant addition is based on receipt of an event from the database, the connection pool does not require manual configuration for that tenant. Once a tenant is added, it can borrow connections from the pool in the same manner as existing tenants, and can also share existing pool properties, such as, for example a maximum pool size, or maximum number of connections per tenant.
Abstract:
In accordance with an embodiment, described herein is a system and method for high availability and load balancing in a database environment. A transparency engine can be provided between client applications and a database, and can operate as a proxy engine for the database and as a session abstraction layer for the client applications, to enable the client applications to utilize database features provided by the connection pool without code changes to the client applications. The transparency can keep track of session states, request boundaries and cursors to efficiently reuse the database connections across the client applications. The transparency engine can use the request boundaries and indicators from the database to detect safe places to drain database connections in the event of database outages.