package clause

type Insert struct {
	Table    Table
	Modifier string
}

// Name insert clause name
func (insert Insert) Name() string {
	return "INSERT"
}

// Build build insert clause
func (insert Insert) Build(builder Builder) {
	if insert.Modifier != "" {
		builder.WriteString(insert.Modifier)
		builder.WriteByte(' ')
	}

	builder.WriteString("INTO ")
	if insert.Table.Name == "" {

      }
    }

    // Insert in chronological order. Always compare deltas because nanoTime() is permitted to wrap.
    var insertAt = futureTasks.indexOfFirst { it.nextExecuteNanoTime - now > delayNanos }
    if (insertAt == -1) insertAt = futureTasks.size
    futureTasks.add(insertAt, task)

    // Impact the coordinator if we inserted at the front.
    return insertAt == 0
  }

  /**

     * Default constructor for AuthenticationManager.
     */
    public AuthenticationManager() {
        // Default constructor
    }

    /**
     * Inserts a new user across all authentication chains.
     * @param user The user to insert.
     */
    public void insert(final User user) {
        chains().of(stream -> stream.forEach(c -> c.update(user)));
    }

    /**

	// create bucket.
	err = obj.MakeBucket(b.Context(), bucket, MakeBucketOptions{})
	if err != nil {
		b.Fatal(err)
	}

	objSize := 128 * humanize.MiByte

	// PutObjectPart returns etag of the object inserted.
	// etag variable is assigned with that value.
	var etag string
	// get text data generated for number of bytes equal to object size.
	textData := generateBytesData(objSize)
	// generate md5sum for the generated data.

     * @return Optional entity containing the bad word if found.
     */
    public OptionalEntity<BadWord> getBadWord(final String id) {
        return badWordBhv.selectByPK(id);
    }

    /**
     * Stores (inserts or updates) a bad word.
     * @param badWord The bad word to store.
     */
    public void store(final BadWord badWord) {

        badWordBhv.insertOrUpdate(badWord, op -> op.setRefreshPolicy(Constants.TRUE));

    public OptionalEntity<User> getUserByName(final String username) {
        return userBhv.selectEntity(cb -> {
            cb.query().setName_Equal(username);
        });
    }

    /**
     * Stores (inserts or updates) a user in the system.
     * Handles user authentication setup and database persistence.
     * If the surname is blank, it will be set to the user's name.
     *
     * @param user the user entity to store

   * Returns the tag attached with [type] as a key. If it is absent, then [computeIfAbsent] is
   * called and that value is both inserted and returned.
   *
   * If multiple calls to this function are made concurrently with the same [type], multiple values
   * may be computed. But only one value will be inserted, and that inserted value will be returned
   * to all callers.
   *

		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Insert{}},
			"INSERT INTO `users`", nil,
		},
		{
			[]clause.Interface{clause.Insert{Modifier: "LOW_PRIORITY"}},
			"INSERT LOW_PRIORITY INTO `users`", nil,
		},
		{
			[]clause.Interface{clause.Insert{Table: clause.Table{Name: "products"}, Modifier: "LOW_PRIORITY"}},
			"INSERT LOW_PRIORITY INTO `products`", nil,
		},
	}

 * change between Java releases.
 *
 * <p><b>Warning:</b> Chunks of data that are put into the {@link Hasher} are not delimited. The
 * resulting {@link HashCode} is dependent only on the bytes inserted, and the order in which they
 * were inserted, not how those bytes were chunked into discrete put() operations. For example, the
 * following three expressions all generate colliding hash codes:
 *
 * {@snippet :

		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{
				clause.Insert{},
				clause.Values{
					Columns: []clause.Column{{Name: "name"}, {Name: "age"}},
					Values:  [][]interface{}{{"jinzhu", 18}, {"josh", 1}},
				},
			},
			"INSERT INTO `users` (`name`,`age`) VALUES (?,?),(?,?)",
			[]interface{}{"jinzhu", 18, "josh", 1},
		},
	}