import java.nio.charset.Charset;

/**
 * A destination to which bytes can be written, such as a file. Unlike an {@link OutputStream}, a
 * {@code ByteSink} is not an open, stateful stream that can be written to and closed. Instead, it
 * is an immutable <i>supplier</i> of {@code OutputStream} instances.
 *
 * <p>{@code ByteSink} provides two kinds of methods:
 *
 * <ul>

Guillaume Nodet <******@****.***> 1729859506 +0200

  public void testSingleQuantile_median() {
    double referenceValue = REFERENCE_ALGORITHM.singleQuantile(1, 2, dataset.clone());
    for (QuantilesAlgorithm algorithm : NON_REFERENCE_ALGORITHMS) {
      assertWithMessage("Mismatch between %s and %s", algorithm, REFERENCE_ALGORITHM)
          .that(algorithm.singleQuantile(1, 2, dataset.clone()))
          .isWithin(ALLOWED_ERROR)
          .of(referenceValue);
    }
  }

 *      writes to, reads from, and closes the pipe in a single operation.
 * <li> <code>TransactNamedPipe</code> A message-type pipe call that
 *      writes to and reads from an existing pipe descriptor in one operation.
 * <li> <code>CreateFile</code>, <code>ReadFile</code>,
 *      <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can
 *      be opened, written to, read from and closed using the standard Win32

      return multiset().subMultiset(fromElement, CLOSED, toElement, OPEN).elementSet();
    }

    @Override
    public SortedSet<E> headSet(@ParametricNullness E toElement) {
      return multiset().headMultiset(toElement, OPEN).elementSet();
    }

    @Override
    public SortedSet<E> tailSet(@ParametricNullness E fromElement) {
      return multiset().tailMultiset(fromElement, CLOSED).elementSet();
    }

    @Override

name: Check closed issue release notes

on:
  issues:
    types: [ closed ]

permissions: {}

jobs:
  check_release_notes:
    permissions:
      issues: write
    runs-on: ubuntu-latest
    steps:
      # Check that release-note-worthy issues have a PR with release notes attached

	if sqldb, ok := connPool.(*sql.DB); ok && sqldb != nil {
		return sqldb, nil
	}

	return nil, ErrInvalidDB
}

func (db *DB) getInstance() *DB {
	if db.clone > 0 {
		tx := &DB{Config: db.Config, Error: db.Error}

		if db.clone == 1 {
			// clone with new statement
			tx.Statement = &Statement{
				DB:        tx,
				ConnPool:  db.Statement.ConnPool,
				Context:   db.Statement.Context,

			s := new(Statement)
			for w := 0; w < whereCount; w++ {
				s = s.clone()
				s.AddClause(clause.Where{
					Exprs: s.BuildCondition(fmt.Sprintf("where%d", w)),
				})
			}

			s1 := s.clone()
			s1.AddClause(clause.Where{
				Exprs: s.BuildCondition("FINAL1"),
			})
			s2 := s.clone()
			s2.AddClause(clause.Where{
				Exprs: s.BuildCondition("FINAL2"),
			})

   * returned range is {@linkplain BoundType#CLOSED closed} on both ends.
   *
   * @since 14.0
   */
  public static <C extends Comparable<?>> Range<C> singleton(C value) {
    return closed(value, value);
  }

  /**
   * Returns the minimal range that {@linkplain Range#contains(Comparable) contains} all of the
   * given values. The returned range is {@linkplain BoundType#CLOSED closed} on both ends.
   *

    protected abstract FileEntry[] getResults ();


    /**
     * 
     */
    protected synchronized void doClose () throws CIFSException {
        // otherwise already closed
        if ( !this.closed ) {
            this.closed = true;
            try {
                doCloseInternal();
            }
            finally {
                this.next = null;
                this.treeHandle.release();