try {
            final Query query = getQueryParser().parse(queryContext.getQueryString());
            final QueryBuilder queryBuilder = ComponentUtil.getQueryProcessor().execute(queryContext, query, 1.0f);
            if (queryBuilder != null) {
                queryContext.setQueryBuilder(queryBuilder);
            } else {
                queryContext.setQueryBuilder(QueryBuilders.matchAllQuery());

        return new Thread(r);
      }
    }

    @Keep
    public static final class DummyExecutor implements Executor, Serializable {
      @Override
      public void execute(Runnable command) {}
    }
  }

  private static final class NullByteSink extends ByteSink implements Serializable {
    private static final NullByteSink INSTANCE = new NullByteSink();

    @Override

    assertTrue(ArbitraryInstances.get(ConcurrentMap.class).isEmpty());
    assertTrue(ArbitraryInstances.get(ConcurrentNavigableMap.class).isEmpty());
    ArbitraryInstances.get(Executor.class).execute(ArbitraryInstances.get(Runnable.class));
    assertThat(ArbitraryInstances.get(ThreadFactory.class)).isNotNull();
    assertFreshInstanceReturned(
        BlockingQueue.class,
        BlockingDeque.class,

    listeners.addListener(listener, executor);
  }

  @Override
  public String toString() {
    return getClass().getSimpleName() + " [" + state() + "]";
  }

  /**
   * Attempts to execute all the listeners in {@link #listeners} while not holding the {@link
   * #monitor}.
   */
  private void dispatchListenerEvents() {
    if (!monitor.isOccupiedByCurrentThread()) {
      listeners.dispatch();
    }

            request.setRemainingBytes(500);
            request.setWriteFlags(0x01);

            byte[] buffer = new byte[1024];
            int headerStart = 64; // Simulated header start

            // Execute
            int bytesWritten = request.writeBytesWireFormat(buffer, headerStart);

            // Verify structure
            assertEquals(49, SMBUtil.readInt2(buffer, headerStart)); // Structure size

              }

              @Override
              public String toString() {
                return callable.toString();
              }
            });
    executor.execute(task);
    return new ClosingFuture<>(task, closeables);
  }

  /**
   * Starts a {@link ClosingFuture} pipeline by submitting a callable block to an executor.
   *

![Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)

* 点击「Try it out」按钮，之后你可以填写参数并直接调用 API：

![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-04-swagger-03.png)

* 然后点击「Execute」按钮，用户界面将会和 API 进行通信，发送参数，获取结果并在屏幕上展示：

![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)

### 可选文档升级

				} else {
					clause.Expr{SQL: sql, Vars: vars}.Build(subdb.Statement)
				}
			} else {
				subdb.Statement.Vars = append(stmt.Vars, subdb.Statement.Vars...)
				subdb.callbacks.Query().Execute(subdb)
			}

			writer.WriteString(subdb.Statement.SQL.String())
			stmt.Vars = subdb.Statement.Vars
		default:
			switch rv := reflect.ValueOf(v); rv.Kind() {
			case reflect.Slice, reflect.Array:

            final UserInfo e = new UserInfo();
            e.setId(userCode);
            e.setCreatedAt(now);
            e.setUpdatedAt(now);
            return e;
        });
        CommonPoolUtil.execute(() -> userInfoBhv.insertOrUpdate(userInfo));
        return userInfo;
    }

    /**
     * Gets user information.
     *
     * @param userCode The user code.
     * @return The user information.

      TimeUnit unit)
      throws InterruptedException {
    Preconditions.checkNotNull(buffer);
    /*
     * This code performs one System.nanoTime() more than necessary, and in return, the time to
     * execute Queue#drainTo is not added *on top* of waiting for the timeout (which could make
     * the timeout arbitrarily inaccurate, given a queue that is slow to drain).
     */