tx = tx.Set("gorm:update_track_time", true)
	}

	if len(selects) > 0 {
		tx = tx.Select(selects)
	} else if restricted && len(omits) == 0 {
		tx = tx.Omit(clause.Associations)
	}

	if len(omits) > 0 {
		tx = tx.Omit(omits...)
	}

	return db.AddError(tx.Create(values).Error)
}

// check association values has been saved
// if values kind is Struct, check it has been saved

   *     {@code null} cause. Note, however, that passing an explicit {@code null} cause prevents
   *     anyone from calling {@link #initCause} later, so it is not quite equivalent to using a
   *     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *

   *     however, that passing an explicit {@code null} cause prevents anyone from calling {@link
   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */
  @Deprecated
  protected ExecutionError() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *

        NegTokenTarg nt = new NegTokenTarg();
        assertEquals(NegTokenTarg.UNSPECIFIED_RESULT, nt.getResult(), "new object should have UNSPECIFIED_RESULT");
    }

    @Test
    @DisplayName("serialization omits tags when field is null")
    void testSerializationOmittingNullFields() throws IOException {
        NegTokenTarg token = new NegTokenTarg();
        token.setResult(NegTokenTarg.ACCEPT_INCOMPLETE);

		Dest:                 stmt.Dest,
		ReflectValue:         stmt.ReflectValue,
		Clauses:              map[string]clause.Clause{},
		Distinct:             stmt.Distinct,
		Selects:              stmt.Selects,
		Omits:                stmt.Omits,
		ColumnMapping:        stmt.ColumnMapping,
		Preloads:             map[string][]interface{}{},
		ConnPool:             stmt.ConnPool,
		Schema:               stmt.Schema,

  /**
   * Returns a string with the URL hostname, socket IP address, and socket port, like one of these:
   *
   *  * `example.com:80 at 1.2.3.4:8888`
   *  * `example.com:443 via proxy [::1]:8888`
   *
   * This omits duplicate information when possible.
   */
  override fun toString(): String =
    buildString {
      val addressHostname = address.url.host // Already in canonical form.

 *
 * <ul>
 *   <li>example.com
 *   <li>example.com:80
 *   <li>192.0.2.1
 *   <li>192.0.2.1:80
 *   <li>[2001:db8::1] - {@link #getHost()} omits brackets
 *   <li>[2001:db8::1]:80 - {@link #getHost()} omits brackets
 *   <li>2001:db8::1 - Use {@link #requireBracketsForIPv6()} to prohibit this
 * </ul>
 *
 * <p>Note that this is not an exhaustive list, because these methods are only concerned with

	}

	return
}

// Omit specify fields that you want to ignore when creating, updating and querying
func (db *DB) Omit(columns ...string) (tx *DB) {
	tx = db.getInstance()

	if len(columns) == 1 && strings.ContainsRune(columns[0], ',') {
		tx.Statement.Omits = strings.FieldsFunc(columns[0], utils.IsInvalidDBNameChar)
	} else {
		tx.Statement.Omits = columns
	}
	return
}

    }

    if (specToApply.cipherSuites != null) {
      sslSocket.enabledCipherSuites = specToApply.cipherSuitesAsString
    }
  }

  /**
   * Returns a copy of this that omits cipher suites and TLS versions not enabled by [sslSocket].
   */
  private fun supportedSpec(
    sslSocket: SSLSocket,
    isFallback: Boolean,
  ): ConnectionSpec {

			}

			if db, ok := jt.Subquery.(interface{ getInstance() *DB }); ok {
				stmt := db.getInstance().Statement
				if len(j.Selects) == 0 {
					j.Selects = stmt.Selects
				}
				if len(j.Omits) == 0 {
					j.Omits = stmt.Omits
				}
			}

			expr := clause.NamedExpr{SQL: fmt.Sprintf("%s JOIN (?) AS ?", joinType), Vars: []interface{}{jt.Subquery, clause.Table{Name: j.Alias}}}

			if j.On != nil {