func NewPreparedStmtDB(connPool ConnPool, maxSize int, ttl time.Duration) *PreparedStmtDB {
	return &PreparedStmtDB{
		ConnPool: connPool,                     // Assigns the provided connection pool to manage database connections.
		Stmts:    stmt_store.New(maxSize, ttl), // Initializes a new statement store with the specified maximum size and TTL.

     *
     * @param maxBuffers the maximum number of buffers to cache
     * @param maxSize the size of each buffer in bytes
     *
     */
    public BufferCacheImpl(final int maxBuffers, final int maxSize) {
        this.cache = new Object[maxBuffers];
        this.bufferSize = maxSize;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.BufferCache#getBuffer()
     */

{
    "properties": {
      "term": {
        "type": "keyword"
      },
      "query": {
        "type": "keyword"
      },
      "maxSize": {
        "type": "integer"
      },
      "boost": {
        "type": "float"
      },
      "virtualHost": {
        "type": "keyword"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },

    }
  }

  public void testSetMaximumSize() {
    // vary maximumSize wrt concurrencyLevel

    for (int maxSize = 1; maxSize < 100; maxSize++) {
      checkMaximumSize(1, 8, maxSize);
      checkMaximumSize(2, 8, maxSize);
      checkMaximumSize(4, 8, maxSize);
      checkMaximumSize(8, 8, maxSize);
    }

    checkMaximumSize(1, 8, Long.MAX_VALUE);
    checkMaximumSize(2, 8, Long.MAX_VALUE);

     * Validates buffer size to prevent overflow
     *
     * @param size the buffer size to validate
     * @param maxSize the maximum allowed size
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */
    public static void validateBufferSize(int size, int maxSize, String fieldName) {
        if (size < 0) {

      }

      @Override
      int minSize() {
        int difference = minSize(set1) - maxSize(set2);
        return difference >= 0 ? difference : max(minSize(set2) - maxSize(set1), 0);
      }

      @Override
      int maxSize() {
        return saturatedAdd(maxSize(set1), maxSize(set2));
      }
    };
  }

  /**

        }
        return super.sink(file, mustCreate)
      }
    }

  /** The maximum number of bytes that this cache should use to store its data. */
  @get:Synchronized @set:Synchronized
  var maxSize: Long = maxSize
    set(value) {
      field = value
      if (initialized) {
        cleanupQueue.schedule(cleanupTask) // Trim the existing store if necessary.
      }
    }

  /*

  constructor(directory: File, maxSize: Long) : this(
    FileSystem.SYSTEM,
    directory.toOkioPath(),
    maxSize,
  )

  internal val cache =
    DiskLruCache(
      fileSystem = fileSystem,
      directory = directory,
      appVersion = VERSION,
      valueCount = ENTRY_COUNT,
      maxSize = maxSize,
      taskRunner = taskRunner,
    )

import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache = Cache(fileSystem, file, maxSize)

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }

internal val Response.exchangeAccessor: Exchange?

  }

  public void testUnion_maxSize_saturated() {
    assertThat(union(setSize(Integer.MAX_VALUE), setSize(1)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
    assertThat(union(setSize(1), setSize(Integer.MAX_VALUE)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
  }

  public void testIntersection_minSize() {
    assertMinSize(intersection(emptySet(), emptySet()), 0);