Oracle International Corporation

Srinath Krishnaswamy

Lakshminarayanan Luxi Chidambaran

Mehul Dilip Bastawala

Ravikanth Kasamsetty

Mohammad Shoaib Lari

Sreenivas Gollapudi

Rajendra Pingte

Debashis Saha

Sanjay Kaluskar

Krishna Mohan Itikarlapalli

Debashish Chatterjee

Sumit Sahu

Juan R Loaiza

Tirthankar Lahiri

Bipul Sinha

Srinivas Vemuri

Susan M Kotsovolos

Tin A Nguyen

Amit Bande

Krishna Mohan, Iv

Sapna Chandiramani

Santanu Datta

Kalyanji Chintakayala

Subhranshu Banerjee

Mohammed Shoaib Lari

Vikas Arora

Douglas James McMahon

Rajesh Kumar

Kevin S Neel

Joyo Wijaya

Ravi Shankar Thammaiah

Anil Nori

Nancy Reiko Ikeda

Sundeep Abraham

Jonathan Giloni

Sreekumar K Seshadri

Dmitry Frumkin

Viswanathan Krishnaomurthy

Lakshminarayanan Chidambaran

Robert Jenkins

Anoop J S

Scot McKinley

I V Krishna Mohan

Iv Krishna Mohan

Disclosed is an improved approach to implement cursor sharing in database systems, where a server-side mapping of cursor identifiers to SQL is maintained to allow for continued use of client-side statement caches even after connections and database sessions are returned to shared pools and then subsequently re-assigned. This avoids the need to clear the statement cache across session releases to the database session pools. Instead, applications can retain their statement cache while still leveraging the benefits of server based pooling solutions.

Using statement caching when implementing server based or proxy based pooling solutions

A server system provided according to an aspect of the present disclosure provides a shared connection pool to parallel execution entities accessing database instances of a distributed database when processing requests. A shared connection pool implies that each pool connection of the connection pool may be used for serving different execution entities requiring access to different database instances. In an embodiment, the database instances correspond to shards together implementing a distributed database, and the parallel execution entities correspond to threads.

Connection pools for parallel processing applications accessing distributed databases

Techniques described herein improve database security by reducing network attack surface area in conjunction with deep input validation. In an embodiment, a database session receives one or more network packets sent via a network, the database session including a database session state that specifies one or more database privileges. The database session reads said one or more network packets into one or more request-packet-buffers, wherein said one or more request-packet-buffers include an RPC op code for a database operation. Based on the one or more database privileges associated with the user associated with the database session, the database session determines whether the RPC op code may be executed. In response to determining that the RPC op code may be executed by said database session, the RPC op code is executed. In response to determining that the op code may not be executed by said database session, the execution of the RPC op code is prevented.

Reducing network attack surface area for a database using deep input validation

Disclosed are methods and apparatuses that implement automatic resizing of statement caches in response to cache metrics. One embodiment provides an approach for periodically calculating a session eligibility index for each session cache, wherein the session eligibility index indicates the priority level of the session cache for resizing, and selecting and resizing one or more cache sessions based at least in part on the session eligibility index.

Statement cache auto-tuning

A method, system, and computer program product is disclosed for interacting with a client supported by a client-side cache. Embodiments of a method, a system, and a computer program product are disclosed that retrieve a first snapshot, indicating a state of the database after a last database request by the client, associated with the client, determine any number of invalid cached results for the client based on the first snapshot, and transmit the any number of invalid cached results and a second snapshot, an update for the first snapshot.

Server supporting a consistent client-side cache

A method, system, and computer program product is disclosed for caching results in a client-side cache. Embodiments of a method, a system, and a computer program product are disclosed that associate a first snapshot of a database with a client that indicates a state of the database after a last database request by the client, and indicate any number of invalid cached results in the client cache for the client based upon the first snapshot. In some embodiments, the method further includes receiving a second snapshot that indicates a state of the database upon receipt of a database server request by the client, and updating the first snapshot with the second snapshot.

Consistent client-side cache

Some embodiments are directed to a method and apparatus for implementing an automatic failover mechanism for a resource. A client accesses a source through a first server using a first session. During the session, the client stores checksum information corresponding to data received via the session with the first server. When it is detected that the session between the first server and the client has failed, the client is automatically connected with second server that has access to the resource. The checksum information is transmitted from the client to the second server, where it is compared with checksum information calculated at the second server, so that a determination can be made as to whether the client can continue processing where it left off when connected to the second server.

Method and system for automatic failover for clients accessing a resource through a server using hybrid checksum location

A server side connection pool provides pooling of server connections. Thus, client side processes do not create groups of dedicated resources. Clients are provided the capability to communicate to a server side connection broker process to GET a pooled server connection comprising connection state plus a thread of execution for doing some work, whereby requesting the work can bypass the connection broker process and go directly to the assigned pooled connection. Once the client issues a RELEASE to release the pooled connection back to the pool, a completely different client process on potentially a different client middle tier machine can reuse the same pooled connection. The server-side connection pool can be logically partitioned into sub-pools that correspond to connection classes that typically correspond to respective applications. A client process can request a pooled connection having a particular state, where a stored procedure can be executed to generate such state.

Server-side connection resource pooling

Multiple groups of read-only files, for use by various components of an application program in a computer, are packaged as follows. Several executable files are prepared, each executable file corresponding to a group of read-only files used by one or more components. Each executable file includes an array that has sufficient space to accommodate the group of read-only files to be packaged therein. Each array in each executable file is overwritten with data from a corresponding group of read-only files. The presence or absence of each executable file for a group of read-only files is indicated by an index that is developed during initialization of components. Retrieval of data is from the executable files, if the index indicates, on first accessing each read-only file, that the corresponding executable file is present. If the executable file is indicated by the index as being absent, then the read-only file is directly accessed.

Packaging multiple groups of read-only files of an application's components into multiple shared libraries

An improved method, mechanism, and system for implementing, generating, and maintaining for implementing session pools is disclosed. A session in a session pool can be customized to with a specific set of affinities and attributes. Tags can be associated with the customized sessions. When a later request is made for a session having a set of desired characteristics, the tags can be used to search for and identify a session in the session pool having the requested characteristics. Also disclosed is a method, mechanism, and system for dynamic sizing of session pools.

Method and mechanism for implementing tagged session pools

One embodiment of the present invention provides a system that facilitates making an inter-process procedure call through a shared memory that is shared between a client process and a server process, wherein the client makes the inter-process procedure call as if the client is making a local procedure call, but the procedure call actually executes on the server. The system operates by an Application Programming Interface (API) to allow the client to make an inter-process procedure call. The system then allocates a section of the shared memory for the data structure parameters of the inter-process procedure call.

Method and apparatus for making inter-process procedure calls through shared memory

One embodiment of the present invention provides a system that facilitates making an inter-process procedure call through a shared memory that is shared between a client process and a server process, wherein the client makes the inter-process procedure call as if the client is making a local procedure call, but the procedure call actually executes on the server. The system operates by providing an Application Programming Interface (API) to allow the client to make an inter-process procedure call. The system then allocates a section of the shared memory for the data structure parameters of the inter-process procedure call.

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.

Suspending a result set and continuing from a suspended result set for scrollable cursors

A computer automatically identifies multiple occurrences of an abstract data type that is embedded within an object of metadata of another abstract data type (hereinafter 'top-level' abstract data type), e.g. by recursively visiting each element of the top-level abstract data type. Then the computer automatically generates, for the top-level abstract data type, a tap-level description that contains a description of each embedded abstract data type. At several locations in the top-level description that correspond to occurrences of a given embedded abstract data type in the top-level abstract data type, the computer automatically inserts offsets that identify a common position where the single description of that given embedded abstract data type is present in the tap-level description. Use of multiple offsets that identify a common position of an embedded description reduces space. The space was otherwise occupied by multiple embedded descriptions in prior art's top-level descriptions.

Reducing memory used by metadata for duplicate user defined types

Growing community of inventors

Fremont, CA, United States of America

Srinath Krishnaswamy