io.milvus.param.collection.FlushParam Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of milvus-sdk-java Show documentation
Show all versions of milvus-sdk-java Show documentation
Java SDK for Milvus, a distributed high-performance vector database.
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package io.milvus.param.collection;
import io.milvus.exception.ParamException;
import io.milvus.param.Constant;
import io.milvus.param.ParamUtils;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
* Parameters for flush interface.
* Note that the flush interface is not exposed currently.
*/
@Getter
@ToString
public class FlushParam {
private final String databaseName;
private final List collectionNames;
private final Boolean syncFlush;
private final long syncFlushWaitingInterval;
private final long syncFlushWaitingTimeout;
private FlushParam(@NonNull Builder builder) {
this.databaseName = builder.databaseName;
this.collectionNames = builder.collectionNames;
this.syncFlush = builder.syncFlush;
this.syncFlushWaitingInterval = builder.syncFlushWaitingInterval;
this.syncFlushWaitingTimeout = builder.syncFlushWaitingTimeout;
}
public static Builder newBuilder() {
return new Builder();
}
/**
* Builder for {@link FlushParam} class.
*/
public static final class Builder {
private String databaseName;
private final List collectionNames = new ArrayList<>();
// syncFlush:
// Default behavior is sync flushing, flush() return after collection finish flushing.
private Boolean syncFlush = Boolean.TRUE;
// syncFlushWaitingInterval:
// When syncFlush is ture, flush() will wait until collection finish flushing,
// this value control the waiting interval. Unit: millisecond. Default value: 500 milliseconds.
private Long syncFlushWaitingInterval = 500L;
// syncFlushWaitingTimeout:
// When syncFlush is ture, flush() will wait until collection finish flushing,
// this value control the waiting timeout. Unit: second. Default value: 60 seconds.
private Long syncFlushWaitingTimeout = 60L;
private Builder() {
}
/**
* Sets the database name. database name can be nil.
*
* @param databaseName database name
* @return Builder
*/
public Builder withDatabaseName(String databaseName) {
this.databaseName = databaseName;
return this;
}
/**
* Sets a list of collections to be flushed.
*
* @param collectionNames a list of collections
* @return Builder
*/
public Builder withCollectionNames(@NonNull List collectionNames) {
this.collectionNames.addAll(collectionNames);
return this;
}
/**
* Adds a collection to be flushed.
*
* @param collectionName name of the collections
* @return Builder
*/
public Builder addCollectionName(@NonNull String collectionName) {
this.collectionNames.add(collectionName);
return this;
}
/**
* Sets the flush function to sync mode.
* With sync mode enabled, the client keeps waiting until all segments of the collection successfully flushed.
*
* If sync mode disabled, client returns at once after the flush() is called.
*
* @param syncFlush Boolean.TRUE is sync mode, Boolean.FALSE is not
* @return Builder
*/
public Builder withSyncFlush(@NonNull Boolean syncFlush) {
this.syncFlush = syncFlush;
return this;
}
/**
* Sets waiting interval in sync mode. With sync mode enabled, the client will constantly check segments state by interval.
* Interval must be greater than zero, and cannot be greater than Constant.MAX_WAITING_FLUSHING_INTERVAL.
* @see Constant
*
* @param milliseconds interval
* @return Builder
*/
public Builder withSyncFlushWaitingInterval(@NonNull Long milliseconds) {
this.syncFlushWaitingInterval = milliseconds;
return this;
}
/**
* Sets timeout value for sync mode.
* Timeout value must be greater than zero, and cannot be greater than Constant.MAX_WAITING_FLUSHING_TIMEOUT.
* @see Constant
*
* @param seconds time out value for sync mode
* @return Builder
*/
public Builder withSyncFlushWaitingTimeout(@NonNull Long seconds) {
this.syncFlushWaitingTimeout = seconds;
return this;
}
/**
* Verifies parameters and creates a new {@link FlushParam} instance.
*
* @return {@link FlushParam}
*/
public FlushParam build() throws ParamException {
if (collectionNames.isEmpty()) {
throw new ParamException("CollectionNames can not be empty");
}
for (String name : collectionNames) {
ParamUtils.CheckNullEmptyString(name, "Collection name");
}
if (Objects.equals(syncFlush, Boolean.TRUE)) {
if (syncFlushWaitingInterval <= 0) {
throw new ParamException("Sync flush waiting interval must be larger than zero");
} else if (syncFlushWaitingInterval > Constant.MAX_WAITING_FLUSHING_INTERVAL) {
throw new ParamException("Sync flush waiting interval cannot be larger than "
+ Constant.MAX_WAITING_FLUSHING_INTERVAL.toString() + " milliseconds");
}
if (syncFlushWaitingTimeout <= 0) {
throw new ParamException("Sync flush waiting timeout must be larger than zero");
} else if (syncFlushWaitingTimeout > Constant.MAX_WAITING_FLUSHING_TIMEOUT) {
throw new ParamException("Sync flush waiting timeout cannot be larger than "
+ Constant.MAX_WAITING_FLUSHING_TIMEOUT.toString() + " seconds");
}
}
return new FlushParam(this);
}
}
}