*
   * <p><b>Performance note:</b> The {@link ImmutableIntArray} that is built will very likely occupy
   * more memory than necessary; to trim memory usage, build using {@code
   * builder.build().trimmed()}.
   */
  public static Builder builder() {
    return new Builder(10);
  }

  /**
   * A builder for {@link ImmutableIntArray} instances; obtained using {@link
   * ImmutableIntArray#builder}.

}

func (s Select) Name() string {
	return "SELECT"
}

func (s Select) Build(builder Builder) {
	if len(s.Columns) > 0 {
		if s.Distinct {
			builder.WriteString("DISTINCT ")
		}

		for idx, column := range s.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}
			builder.WriteQuoted(column)
		}
	} else {
		builder.WriteByte('*')
	}
}

func (s Select) MergeClause(clause *Clause) {

      private val client = OkHttpClient.Builder()
          .certificatePinner(
              CertificatePinner.Builder()
                  .add("publicobject.com", "sha256/afwiKY3RxoMmLkuRW1l7QsPZTJPwDS2pdDROQjXw8ig=")
                  .build())
          .build()

      fun run() {
        val request = Request.Builder()
            .url("https://publicobject.com/robots.txt")
            .build()

	public final fun rsa2048 ()Lokhttp3/tls/HeldCertificate$Builder;
	public final fun serialNumber (J)Lokhttp3/tls/HeldCertificate$Builder;
	public final fun serialNumber (Ljava/math/BigInteger;)Lokhttp3/tls/HeldCertificate$Builder;
	public final fun signedBy (Lokhttp3/tls/HeldCertificate;)Lokhttp3/tls/HeldCertificate$Builder;
	public final fun validityInterval (JJ)Lokhttp3/tls/HeldCertificate$Builder;
}

	}
}

func (join Join) Build(builder Builder) {
	if join.Expression != nil {
		join.Expression.Build(builder)
	} else {
		if join.Type != "" {
			builder.WriteString(string(join.Type))
			builder.WriteByte(' ')
		}

		builder.WriteString("JOIN ")
		builder.WriteQuoted(join.Table)

		if len(join.ON.Exprs) > 0 {
			builder.WriteString(" ON ")
			join.ON.Build(builder)
		} else if len(join.Using) > 0 {

  }

  @Test
  fun testCacheEvents() {
    val request = Request.Builder().url(url).build()
    val call = client.newCall(request)
    val response =
      Response
        .Builder()
        .request(request)
        .code(200)
        .message("")
        .protocol(Protocol.HTTP_2)
        .build()
    val listener = loggingEventListenerFactory.create(call)

  @Test fun httpExceptionsAreReturnedAsSuppressed() {
    server.enqueue(MockResponse.Builder().onRequestStart(CloseSocket()).build())
    server.enqueue(MockResponse.Builder().onRequestStart(CloseSocket()).build())

    client =
      client
        .newBuilder()
        .dns(DoubleInetAddressDns()) // Two routes so we get two failures.
        .build()

    val request = Request(server.url("/"))
    assertFailsWith<IOException> {

        .addTrustedCertificate(localhostCertificate.certificate())
        .build();
    OkHttpClient client = new OkHttpClient.Builder()
        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager())
        .build();

    Call call = client.newCall(new Request.Builder()
        .url(server.url("/"))
        .build());
    Response response = call.execute();

    val heldCertificate =
      HeldCertificate
        .Builder()
        .addSubjectAlternativeName("example.com")
        .build()
    val serverCertificates =
      HandshakeCertificates
        .Builder()
        .heldCertificate(heldCertificate)
        .build()
    server.useHttps(serverCertificates.sslSocketFactory())
    server.enqueue(MockResponse())

   *         .addNode(ICELAND)
   *         .build();
   * }
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
   * multiple graphs in series. Each new graph contains all the elements of the ones created before
   * it.
   *
   * @since 28.0
   */
  public static class Builder<N> {

    private final MutableGraph<N> mutableGraph;