milvusclient

package
v2.0.0-...-b3791a6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 27, 2025 License: Apache-2.0 Imports: 40 Imported by: 3

Documentation

Overview

Package milvusclient implements the official Go Milvus client for v2.

Index

Examples

Constants

View Source 
const (
	RetryOnRateLimit ctxKey = iota
)

Variables

View Source 
var DefaultGrpcOpts = []grpc.DialOption{
	grpc.WithBlock(),
	grpc.WithKeepaliveParams(keepalive.ClientParameters{
		Time:                5 * time.Second,
		Timeout:             10 * time.Second,
		PermitWithoutStream: true,
	}),
	grpc.WithConnectParams(grpc.ConnectParams{
		Backoff: backoff.Config{
			BaseDelay:  100 * time.Millisecond,
			Multiplier: 1.6,
			Jitter:     0.2,
			MaxDelay:   3 * time.Second,
		},
		MinConnectTimeout: 3 * time.Second,
	}),
	grpc.WithDefaultCallOptions(
		grpc.MaxCallRecvMsgSize(math.MaxInt32),
	),
}

DefaultGrpcOpts is GRPC options for milvus client.

Functions

func NewAlterAliasOption 

func NewAlterAliasOption(alias, collectionName string) *alterAliasOption

func NewAlterCollectionFieldPropertiesOption 

func NewAlterCollectionFieldPropertiesOption(collectionName string, fieldName string) *alterCollectionFieldPropertiesOption

func NewAlterCollectionPropertiesOption 

func NewAlterCollectionPropertiesOption(collection string) *alterCollectionPropertiesOption

func NewAlterDatabasePropertiesOption 

func NewAlterDatabasePropertiesOption(dbName string) *alterDatabasePropertiesOption

func NewAnnRequest 

func NewAnnRequest(annField string, limit int, vectors ...entity.Vector) *annRequest

func NewColumnBasedInsertOption 

func NewColumnBasedInsertOption(collName string, columns ...column.Column) *columnBasedDataOption

func NewCompactOption 

func NewCompactOption(collectionName string) *compactOption

func NewCreateAliasOption 

func NewCreateAliasOption(collectionName, alias string) *createAliasOption

func NewCreateCollectionOption 

func NewCreateCollectionOption(name string, collectionSchema *entity.Schema) *createCollectionOption

NewCreateCollectionOption returns a CreateCollectionOption with customized collection schema

func NewCreateDatabaseOption 

func NewCreateDatabaseOption(dbName string) *createDatabaseOption

func NewCreateIndexOption 

func NewCreateIndexOption(collectionName string, fieldName string, index index.Index) *createIndexOption

func NewCreatePartitionOption 

func NewCreatePartitionOption(collectionName string, partitionName string) *createPartitionOpt

func NewCreatePrivilegeGroupOption 

func NewCreatePrivilegeGroupOption(groupName string) *createPrivilegeGroupOption

func NewCreateResourceGroupOption 

func NewCreateResourceGroupOption(name string) *createResourceGroupOption

func NewCreateRoleOption 

func NewCreateRoleOption(roleName string) *createRoleOption

func NewCreateUserOption 

func NewCreateUserOption(userName, password string) *createUserOption

func NewDeleteOption 

func NewDeleteOption(collectionName string) *deleteOption

func NewDescribeAliasOption 

func NewDescribeAliasOption(alias string) *describeAliasOption

func NewDescribeCollectionOption 

func NewDescribeCollectionOption(name string) *describeCollectionOption

NewDescribeCollectionOption composes a describeCollectionOption with provided collection name.

func NewDescribeDatabaseOption 

func NewDescribeDatabaseOption(dbName string) *describeDatabaseOption

func NewDescribeIndexOption 

func NewDescribeIndexOption(collectionName string, indexName string) *describeIndexOption

func NewDescribeResourceGroupOption 

func NewDescribeResourceGroupOption(name string) *describeResourceGroupOption

func NewDescribeRoleOption 

func NewDescribeRoleOption(roleName string) *describeRoleOption

func NewDescribeUserOption 

func NewDescribeUserOption(userName string) *describeUserOption

func NewDropAliasOption 

func NewDropAliasOption(alias string) *dropAliasOption

func NewDropCollectionOption 

func NewDropCollectionOption(name string) *dropCollectionOption

func NewDropCollectionPropertiesOption 

func NewDropCollectionPropertiesOption(collection string, propertyKeys ...string) *dropCollectionPropertiesOption

func NewDropDatabaseOption 

func NewDropDatabaseOption(dbName string) *dropDatabaseOption

func NewDropDatabasePropertiesOption 

func NewDropDatabasePropertiesOption(dbName string, propertyKeys ...string) *dropDatabasePropertiesOption

func NewDropIndexOption 

func NewDropIndexOption(collectionName string, indexName string) *dropIndexOption

func NewDropPartitionOption 

func NewDropPartitionOption(collectionName string, partitionName string) *dropPartitionOpt

func NewDropPrivilegeGroupOption 

func NewDropPrivilegeGroupOption(groupName string) *dropPrivilegeGroupOption

func NewDropResourceGroupOption 

func NewDropResourceGroupOption(name string) *dropResourceGroupOption

func NewDropRoleOption 

func NewDropRoleOption(roleName string) *dropDropRoleOption

func NewDropUserOption 

func NewDropUserOption(userName string) *dropUserOption

func NewFlushOption 

func NewFlushOption(collName string) *flushOption

func NewGetCollectionStatsOption 

func NewGetCollectionStatsOption(collectionName string) *getCollectionStatsOption

func NewGetCompactionStateOption 

func NewGetCompactionStateOption(compactionID int64) *getCompactionStateOption

func NewGetLoadStateOption 

func NewGetLoadStateOption(collectionName string, partitionNames ...string) *getLoadStateOption

func NewGetPartitionStatsOption 

func NewGetPartitionStatsOption(collectionName string, partitionName string) *getPartitionStatsOpt

func NewGetServerVersionOption 

func NewGetServerVersionOption() *getServerVersionOption

func NewGrantPrivilegeOption 

func NewGrantPrivilegeOption(roleName, objectType, privilegeName, objectName string) *grantPrivilegeOption

func NewGrantRoleOption 

func NewGrantRoleOption(userName, roleName string) *grantRoleOption

func NewGrantV2Option 

func NewGrantV2Option(roleName, privilegeName, dbName, collectionName string) *grantV2Option

func NewHasPartitionOption 

func NewHasPartitionOption(collectionName string, partitionName string) *hasPartitionOpt

func NewHybridSearchOption 

func NewHybridSearchOption(collectionName string, limit int, annRequests ...*annRequest) *hybridSearchOption

func NewListAliasesOption 

func NewListAliasesOption(collectionName string) *listAliasesOption

func NewListCollectionOption 

func NewListCollectionOption() *listCollectionOption

func NewListDatabaseOption 

func NewListDatabaseOption() *listDatabaseOption

func NewListIndexOption 

func NewListIndexOption(collectionName string) *listIndexOption

func NewListPartitionOption 

func NewListPartitionOption(collectionName string) *listPartitionsOpt

func NewListPrivilegeGroupsOption 

func NewListPrivilegeGroupsOption() *listPrivilegeGroupsOption

func NewListResourceGroupsOption 

func NewListResourceGroupsOption() *listResourceGroupsOption

func NewListRoleOption 

func NewListRoleOption() *listRoleOption

func NewListUserOption 

func NewListUserOption() *listUserOption

func NewLoadCollectionOption 

func NewLoadCollectionOption(collectionName string) *loadCollectionOption

func NewLoadPartitionsOption 

func NewLoadPartitionsOption(collectionName string, partitionsNames ...string) *loadPartitionsOption

func NewOperatePrivilegeGroupOption 

func NewOperatePrivilegeGroupOption(groupName string, privileges []*milvuspb.PrivilegeEntity, operateType milvuspb.OperatePrivilegeGroupType) *operatePrivilegeGroupOption

func NewQueryOption 

func NewQueryOption(collectionName string) *queryOption

func NewRRFReranker 

func NewRRFReranker() *rrfReranker

func NewRefreshLoadOption 

func NewRefreshLoadOption(collectionName string) *refreshLoadOption

func NewReleaseCollectionOption 

func NewReleaseCollectionOption(collectionName string) *releaseCollectionOption

func NewReleasePartitionsOptions 

func NewReleasePartitionsOptions(collectionName string, partitionNames ...string) *releasePartitionsOption

func NewRenameCollectionOption 

func NewRenameCollectionOption(oldName, newName string) *renameCollectionOption

func NewRevokePrivilegeOption 

func NewRevokePrivilegeOption(roleName, objectType, privilegeName, objectName string) *revokePrivilegeOption

func NewRevokeRoleOption 

func NewRevokeRoleOption(userName, roleName string) *revokeRoleOption

func NewRevokeV2Option 

func NewRevokeV2Option(roleName, privilegeName, dbName, collectionName string) *revokeV2Option

func NewRowBasedInsertOption 

func NewRowBasedInsertOption(collName string, rows ...any) *rowBasedDataOption

func NewSearchOption 

func NewSearchOption(collectionName string, limit int, vectors []entity.Vector) *searchOption

func NewTransferReplicaOption 

func NewTransferReplicaOption(collectionName, sourceGroup, targetGroup string, replicaNum int64) *transferReplicaOption

func NewUpdatePasswordOption 

func NewUpdatePasswordOption(userName, oldPassword, newPassword string) *updatePasswordOption

func NewUpdateResourceGroupOption 

func NewUpdateResourceGroupOption(name string, resourceGroupConfig *entity.ResourceGroupConfig) *updateResourceGroupOption

func NewUseDatabaseOption 

func NewUseDatabaseOption(dbName string) *useDatabaseNameOpt

func NewWeightedReranker 

func NewWeightedReranker(weights []float64) *weightedReranker

func RetryOnRateLimitInterceptor 

func RetryOnRateLimitInterceptor(maxRetry uint, maxBackoff time.Duration, backoffFunc grpc_retry.BackoffFuncContext) grpc.UnaryClientInterceptor

RetryOnRateLimitInterceptor returns a new retrying unary client interceptor.

func SimpleCreateCollectionOptions 

func SimpleCreateCollectionOptions(name string, dim int64) *createCollectionOption

SimpleCreateCollectionOptions returns a CreateCollectionOption with default fast collection options.

Types

type AlterAliasOption 

type AlterAliasOption interface {
	Request() *milvuspb.AlterAliasRequest
}

AlterAliasOption is the interface builds AlterAliasRequest.

type AlterCollectionFieldPropertiesOption 

type AlterCollectionFieldPropertiesOption interface {
	Request() *milvuspb.AlterCollectionFieldRequest
}

type AlterCollectionPropertiesOption 

type AlterCollectionPropertiesOption interface {
	Request() *milvuspb.AlterCollectionRequest
}

type AlterDatabasePropertiesOption 

type AlterDatabasePropertiesOption interface {
	Request() *milvuspb.AlterDatabaseRequest
}

type BackupRBACOption 

type BackupRBACOption interface {
	Request() *milvuspb.BackupRBACMetaRequest
}

func NewBackupRBACOption 

func NewBackupRBACOption() BackupRBACOption

type Client 

type Client struct {
	// contains filtered or unexported fields
}

func New 

func New(ctx context.Context, config *ClientConfig) (*Client, error)

func (*Client) AlterAlias 

func (c *Client) AlterAlias(ctx context.Context, option AlterAliasOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"
	"fmt"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	err = cli.AlterAlias(ctx, milvusclient.NewAlterAliasOption("alice", "customized_setup_1"))
	if err != nil {
		// handle error
	}

	aliases, err := cli.ListAliases(ctx, milvusclient.NewListAliasesOption("customized_setup_1"))
	if err != nil {
		// handle error
	}
	fmt.Println(aliases)

	aliases, err = cli.ListAliases(ctx, milvusclient.NewListAliasesOption("customized_setup_2"))
	if err != nil {
		// handle error
	}
	fmt.Println(aliases)
}

Output:

func (*Client) AlterCollectionFieldProperty 

func (c *Client) AlterCollectionFieldProperty(ctx context.Context, option AlterCollectionFieldPropertiesOption, callOptions ...grpc.CallOption) error

func (*Client) AlterCollectionProperties 

func (c *Client) AlterCollectionProperties(ctx context.Context, option AlterCollectionPropertiesOption, callOptions ...grpc.CallOption) error

func (*Client) AlterDatabaseProperties 

func (c *Client) AlterDatabaseProperties(ctx context.Context, option AlterDatabasePropertiesOption, callOptions ...grpc.CallOption) error

func (*Client) BackupRBAC 

func (c *Client) BackupRBAC(ctx context.Context, option BackupRBACOption, callOptions ...grpc.CallOption) (*entity.RBACMeta, error)

func (*Client) Close 

func (c *Client) Close(ctx context.Context) error

func (*Client) Compact 

func (c *Client) Compact(ctx context.Context, option CompactOption, callOptions ...grpc.CallOption) (int64, error)

func (*Client) CreateAlias 

func (c *Client) CreateAlias(ctx context.Context, option CreateAliasOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	err = cli.CreateAlias(ctx, milvusclient.NewCreateAliasOption("customized_setup_2", "bob"))
	if err != nil {
		// handle error
	}

	err = cli.CreateAlias(ctx, milvusclient.NewCreateAliasOption("customized_setup_2", "alice"))
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) CreateCollection 

func (c *Client) CreateCollection(ctx context.Context, option CreateCollectionOption, callOptions ...grpc.CallOption) error

CreateCollection is the API for create a collection in Milvus.

Example (ConsistencyLevel) 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

const milvusAddr = `127.0.0.1:19530`

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	collectionName := `customized_setup_5`

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle err
	}

	schema := entity.NewSchema().WithDynamicFieldEnabled(true).
		WithField(entity.NewField().WithName("my_id").WithIsAutoID(true).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).
		WithField(entity.NewField().WithName("my_vector").WithDataType(entity.FieldTypeFloatVector).WithDim(5)).
		WithField(entity.NewField().WithName("my_varchar").WithDataType(entity.FieldTypeVarChar).WithMaxLength(512))

	err = cli.CreateCollection(ctx, milvusclient.NewCreateCollectionOption(collectionName, schema).WithConsistencyLevel(entity.ClBounded))
	if err != nil {
		// handle error
	}
}

Output:
Example (EnableMmap) 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
	"github.com/milvus-io/milvus/pkg/common"
)

const milvusAddr = `127.0.0.1:19530`

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	collectionName := `customized_setup_4`

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle err
	}

	schema := entity.NewSchema().WithDynamicFieldEnabled(true).
		WithField(entity.NewField().WithName("my_id").WithIsAutoID(true).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).
		WithField(entity.NewField().WithName("my_vector").WithDataType(entity.FieldTypeFloatVector).WithDim(5)).
		WithField(entity.NewField().WithName("my_varchar").WithDataType(entity.FieldTypeVarChar).WithMaxLength(512))

	err = cli.CreateCollection(ctx, milvusclient.NewCreateCollectionOption(collectionName, schema).WithProperty(common.MmapEnabledKey, true))
	if err != nil {
		// handle error
	}
}

Output:
Example (Normal) 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/index"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

const milvusAddr = `127.0.0.1:19530`

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	collectionName := `customized_setup_1`

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle err
	}

	indexOptions := []milvusclient.CreateIndexOption{
		milvusclient.NewCreateIndexOption(collectionName, "my_vector", index.NewAutoIndex(entity.COSINE)).WithIndexName("my_vector"),
		milvusclient.NewCreateIndexOption(collectionName, "my_id", index.NewSortedIndex()).WithIndexName("my_id"),
	}

	schema := entity.NewSchema().WithDynamicFieldEnabled(true).
		WithField(entity.NewField().WithName("my_id").WithIsAutoID(true).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).
		WithField(entity.NewField().WithName("my_vector").WithDataType(entity.FieldTypeFloatVector).WithDim(5)).
		WithField(entity.NewField().WithName("my_varchar").WithDataType(entity.FieldTypeVarChar).WithMaxLength(512))

	err = cli.CreateCollection(ctx, milvusclient.NewCreateCollectionOption(collectionName, schema).
		WithIndexOptions(indexOptions...),
	)
	if err != nil {
		// handle error
	}
}

Output:
Example (Quick) 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

const milvusAddr = `127.0.0.1:19530`

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	collectionName := `quick_setup`

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle err
	}

	err = cli.CreateCollection(ctx, milvusclient.SimpleCreateCollectionOptions(collectionName, 5))
	if err != nil {
		// handle error
	}
}

Output:
Example (ShardNum) 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

const milvusAddr = `127.0.0.1:19530`

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	collectionName := `customized_setup_3`

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle err
	}

	schema := entity.NewSchema().WithDynamicFieldEnabled(true).
		WithField(entity.NewField().WithName("my_id").WithIsAutoID(true).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).
		WithField(entity.NewField().WithName("my_vector").WithDataType(entity.FieldTypeFloatVector).WithDim(5)).
		WithField(entity.NewField().WithName("my_varchar").WithDataType(entity.FieldTypeVarChar).WithMaxLength(512))

	err = cli.CreateCollection(ctx, milvusclient.NewCreateCollectionOption(collectionName, schema).WithShardNum(1))
	if err != nil {
		// handle error
	}
}

Output:
Example (Ttl) 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
	"github.com/milvus-io/milvus/pkg/common"
)

const milvusAddr = `127.0.0.1:19530`

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	collectionName := `customized_setup_5`

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle err
	}

	schema := entity.NewSchema().WithDynamicFieldEnabled(true).
		WithField(entity.NewField().WithName("my_id").WithIsAutoID(true).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).
		WithField(entity.NewField().WithName("my_vector").WithDataType(entity.FieldTypeFloatVector).WithDim(5)).
		WithField(entity.NewField().WithName("my_varchar").WithDataType(entity.FieldTypeVarChar).WithMaxLength(512))

	err = cli.CreateCollection(ctx, milvusclient.NewCreateCollectionOption(collectionName, schema).WithProperty(common.CollectionTTLConfigKey, 86400))
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) CreateDatabase 

func (c *Client) CreateDatabase(ctx context.Context, option CreateDatabaseOption, callOptions ...grpc.CallOption) error

func (*Client) CreateIndex 

func (c *Client) CreateIndex(ctx context.Context, option CreateIndexOption, callOptions ...grpc.CallOption) (*CreateIndexTask, error)

func (*Client) CreatePartition 

func (c *Client) CreatePartition(ctx context.Context, opt CreatePartitionOption, callOptions ...grpc.CallOption) error

CreatePartition is the API for creating a partition for a collection.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	defer cli.Close(ctx)

	err = cli.CreatePartition(ctx, milvusclient.NewCreatePartitionOption("quick_setup", "partitionA"))
	if err != nil {
		// handle error
	}

	partitionNames, err := cli.ListPartitions(ctx, milvusclient.NewListPartitionOption("quick_setup"))
	if err != nil {
		// handle error
	}

	fmt.Println(partitionNames)
}

Output:

func (*Client) CreatePrivilegeGroup 

func (c *Client) CreatePrivilegeGroup(ctx context.Context, option CreatePrivilegeGroupOption, callOptions ...grpc.CallOption) error

func (*Client) CreateResourceGroup 

func (c *Client) CreateResourceGroup(ctx context.Context, opt CreateResourceGroupOption, callOptions ...grpc.CallOption) error

func (*Client) CreateRole 

func (c *Client) CreateRole(ctx context.Context, opt CreateRoleOption, callOpts ...grpc.CallOption) error

func (*Client) CreateUser 

func (c *Client) CreateUser(ctx context.Context, opt CreateUserOption, callOpts ...grpc.CallOption) error

func (*Client) Delete 

func (c *Client) Delete(ctx context.Context, option DeleteOption, callOptions ...grpc.CallOption) (DeleteResult, error)

func (*Client) DescribeAlias 

func (c *Client) DescribeAlias(ctx context.Context, option DescribeAliasOption, callOptions ...grpc.CallOption) (*entity.Alias, error)
Example 
package main

import (
	"context"
	"fmt"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	alias, err := cli.DescribeAlias(ctx, milvusclient.NewDescribeAliasOption("bob"))
	if err != nil {
		// handle error
	}
	fmt.Println(alias)
}

Output:

func (*Client) DescribeCollection 

func (c *Client) DescribeCollection(ctx context.Context, option DescribeCollectionOption, callOptions ...grpc.CallOption) (collection *entity.Collection, err error)
Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	collection, err := cli.DescribeCollection(ctx, milvusclient.NewDescribeCollectionOption("quick_setup"))
	if err != nil {
		// handle error
	}

	fmt.Println(collection)
}

Output:

func (*Client) DescribeDatabase 

func (c *Client) DescribeDatabase(ctx context.Context, option DescribeDatabaseOption, callOptions ...grpc.CallOption) (*entity.Database, error)

func (*Client) DescribeIndex 

func (c *Client) DescribeIndex(ctx context.Context, opt DescribeIndexOption, callOptions ...grpc.CallOption) (IndexDescription, error)

func (*Client) DescribeResourceGroup 

func (c *Client) DescribeResourceGroup(ctx context.Context, opt DescribeResourceGroupOption, callOptions ...grpc.CallOption) (*entity.ResourceGroup, error)

func (*Client) DescribeRole 

func (c *Client) DescribeRole(ctx context.Context, option DescribeRoleOption, callOptions ...grpc.CallOption) (*entity.Role, error)

func (*Client) DescribeUser 

func (c *Client) DescribeUser(ctx context.Context, opt DescribeUserOption, callOpts ...grpc.CallOption) (*entity.User, error)

func (*Client) DropAlias 

func (c *Client) DropAlias(ctx context.Context, option DropAliasOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	err = cli.DropAlias(ctx, milvusclient.NewDropAliasOption("alice"))
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) DropCollection 

func (c *Client) DropCollection(ctx context.Context, option DropCollectionOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	err = cli.DropCollection(ctx, milvusclient.NewDropCollectionOption("customized_setup_2"))
	if err != nil {
		// handle err
	}
}

Output:

func (*Client) DropCollectionProperties 

func (c *Client) DropCollectionProperties(ctx context.Context, option DropCollectionPropertiesOption, callOptions ...grpc.CallOption) error

func (*Client) DropDatabase 

func (c *Client) DropDatabase(ctx context.Context, option DropDatabaseOption, callOptions ...grpc.CallOption) error

func (*Client) DropDatabaseProperties 

func (c *Client) DropDatabaseProperties(ctx context.Context, option DropDatabasePropertiesOption, callOptions ...grpc.CallOption) error

func (*Client) DropIndex 

func (c *Client) DropIndex(ctx context.Context, opt DropIndexOption, callOptions ...grpc.CallOption) error

func (*Client) DropPartition 

func (c *Client) DropPartition(ctx context.Context, opt DropPartitionOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	defer cli.Close(ctx)

	err = cli.DropPartition(ctx, milvusclient.NewDropPartitionOption("quick_setup", "partitionA"))
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) DropPrivilegeGroup 

func (c *Client) DropPrivilegeGroup(ctx context.Context, option DropPrivilegeGroupOption, callOptions ...grpc.CallOption) error

func (*Client) DropResourceGroup 

func (c *Client) DropResourceGroup(ctx context.Context, opt DropResourceGroupOption, callOptions ...grpc.CallOption) error

func (*Client) DropRole 

func (c *Client) DropRole(ctx context.Context, opt DropRoleOption, callOpts ...grpc.CallOption) error

func (*Client) DropUser 

func (c *Client) DropUser(ctx context.Context, opt DropUserOption, callOpts ...grpc.CallOption) error

func (*Client) Flush 

func (c *Client) Flush(ctx context.Context, option FlushOption, callOptions ...grpc.CallOption) (*FlushTask, error)

func (*Client) Get 

func (c *Client) Get(ctx context.Context, option QueryOption, callOptions ...grpc.CallOption) (ResultSet, error)

func (*Client) GetCollectionStats 

func (c *Client) GetCollectionStats(ctx context.Context, opt GetCollectionOption) (map[string]string, error)

func (*Client) GetCompactionState 

func (c *Client) GetCompactionState(ctx context.Context, option GetCompactionStateOption, callOptions ...grpc.CallOption) (entity.CompactionState, error)

func (*Client) GetLoadState 

func (c *Client) GetLoadState(ctx context.Context, option GetLoadStateOption, callOptions ...grpc.CallOption) (entity.LoadState, error)

func (*Client) GetPartitionStats 

func (c *Client) GetPartitionStats(ctx context.Context, opt GetPartitionStatsOption, callOptions ...grpc.CallOption) (map[string]string, error)

func (*Client) GetPersistentSegmentInfo 

func (c *Client) GetPersistentSegmentInfo(ctx context.Context, option GetPersistentSegmentInfoOption) ([]*entity.Segment, error)

func (*Client) GetServerVersion 

func (c *Client) GetServerVersion(ctx context.Context, option GetServerVersionOption, callOptions ...grpc.CallOption) (string, error)

GetServerVersion returns connect Milvus instance version.

func (*Client) GrantPrivilege 

func (c *Client) GrantPrivilege(ctx context.Context, option GrantPrivilegeOption, callOptions ...grpc.CallOption) error

func (*Client) GrantRole 

func (c *Client) GrantRole(ctx context.Context, opt GrantRoleOption, callOpts ...grpc.CallOption) error

func (*Client) GrantV2 

func (c *Client) GrantV2(ctx context.Context, option GrantV2Option, callOptions ...grpc.CallOption) error

func (*Client) HasCollection 

func (c *Client) HasCollection(ctx context.Context, option HasCollectionOption, callOptions ...grpc.CallOption) (has bool, err error)

func (*Client) HasPartition 

func (c *Client) HasPartition(ctx context.Context, opt HasPartitionOption, callOptions ...grpc.CallOption) (has bool, err error)
Example 
package main

import (
	"context"
	"fmt"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	defer cli.Close(ctx)
	result, err := cli.HasPartition(ctx, milvusclient.NewHasPartitionOption("quick_setup", "partitionA"))
	if err != nil {
		// handle error
	}

	fmt.Println(result)
}

Output:

func (*Client) HybridSearch 

func (c *Client) HybridSearch(ctx context.Context, option HybridSearchOption, callOptions ...grpc.CallOption) ([]ResultSet, error)

func (*Client) Insert 

func (c *Client) Insert(ctx context.Context, option InsertOption, callOptions ...grpc.CallOption) (InsertResult, error)

func (*Client) ListAliases 

func (c *Client) ListAliases(ctx context.Context, option ListAliasesOption, callOptions ...grpc.CallOption) ([]string, error)
Example 
package main

import (
	"context"
	"fmt"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	aliases, err := cli.ListAliases(ctx, milvusclient.NewListAliasesOption("customized_setup_2"))
	if err != nil {
		// handle error
	}
	fmt.Println(aliases)
}

Output:

func (*Client) ListCollections 

func (c *Client) ListCollections(ctx context.Context, option ListCollectionOption, callOptions ...grpc.CallOption) (collectionNames []string, err error)
Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	collectionNames, err := cli.ListCollections(ctx, milvusclient.NewListCollectionOption())
	if err != nil {
		// handle error
	}

	fmt.Println(collectionNames)
}

Output:

func (*Client) ListDatabase 

func (c *Client) ListDatabase(ctx context.Context, option ListDatabaseOption, callOptions ...grpc.CallOption) (databaseNames []string, err error)

func (*Client) ListIndexes 

func (c *Client) ListIndexes(ctx context.Context, opt ListIndexOption, callOptions ...grpc.CallOption) ([]string, error)

func (*Client) ListPartitions 

func (c *Client) ListPartitions(ctx context.Context, opt ListPartitionsOption, callOptions ...grpc.CallOption) (partitionNames []string, err error)
Example 
package main

import (
	"context"
	"fmt"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	defer cli.Close(ctx)

	partitionNames, err := cli.ListPartitions(ctx, milvusclient.NewListPartitionOption("quick_setup"))
	if err != nil {
		// handle error
	}

	fmt.Println(partitionNames)
}

Output:

func (*Client) ListPrivilegeGroups 

func (c *Client) ListPrivilegeGroups(ctx context.Context, option ListPrivilegeGroupsOption, callOptions ...grpc.CallOption) ([]*entity.PrivilegeGroup, error)

func (*Client) ListResourceGroups 

func (c *Client) ListResourceGroups(ctx context.Context, opt ListResourceGroupsOption, callOptions ...grpc.CallOption) ([]string, error)

func (*Client) ListRoles 

func (c *Client) ListRoles(ctx context.Context, opt ListRoleOption, callOpts ...grpc.CallOption) ([]string, error)

func (*Client) ListUsers 

func (c *Client) ListUsers(ctx context.Context, opt ListUserOption, callOpts ...grpc.CallOption) ([]string, error)

func (*Client) LoadCollection 

func (c *Client) LoadCollection(ctx context.Context, option LoadCollectionOption, callOptions ...grpc.CallOption) (LoadTask, error)
Example 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	loadTask, err := cli.LoadCollection(ctx, milvusclient.NewLoadCollectionOption("customized_setup_1"))
	if err != nil {
		// handle error
	}

	// sync wait collection to be loaded
	err = loadTask.Await(ctx)
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) LoadPartitions 

func (c *Client) LoadPartitions(ctx context.Context, option LoadPartitionsOption, callOptions ...grpc.CallOption) (LoadTask, error)
Example 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	defer cli.Close(ctx)

	task, err := cli.LoadPartitions(ctx, milvusclient.NewLoadPartitionsOption("quick_setup", "partitionA"))

	// sync wait collection to be loaded
	err = task.Await(ctx)
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) MetadataUnaryInterceptor 

func (c *Client) MetadataUnaryInterceptor() grpc.UnaryClientInterceptor

func (*Client) OperatePrivilegeGroup 

func (c *Client) OperatePrivilegeGroup(ctx context.Context, option OperatePrivilegeGroupOption, callOptions ...grpc.CallOption) error

func (*Client) Query 

func (c *Client) Query(ctx context.Context, option QueryOption, callOptions ...grpc.CallOption) (ResultSet, error)

func (*Client) RefreshLoad 

func (c *Client) RefreshLoad(ctx context.Context, option RefreshLoadOption, callOptions ...grpc.CallOption) (LoadTask, error)

func (*Client) ReleaseCollection 

func (c *Client) ReleaseCollection(ctx context.Context, option ReleaseCollectionOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	err = cli.ReleaseCollection(ctx, milvusclient.NewReleaseCollectionOption("custom_quick_setup"))
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) ReleasePartitions 

func (c *Client) ReleasePartitions(ctx context.Context, option ReleasePartitionsOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		// handle error
	}

	defer cli.Close(ctx)

	err = cli.ReleasePartitions(ctx, milvusclient.NewReleasePartitionsOptions("quick_setup", "partitionA"))
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) RenameCollection 

func (c *Client) RenameCollection(ctx context.Context, option RenameCollectionOption, callOptions ...grpc.CallOption) error
Example 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	err = cli.RenameCollection(ctx, milvusclient.NewRenameCollectionOption("my_collection", "my_new_collection"))
	if err != nil {
		// handle error
	}
}

Output:

func (*Client) RestoreRBAC 

func (c *Client) RestoreRBAC(ctx context.Context, option RestoreRBACOption, callOptions ...grpc.CallOption) error

func (*Client) RevokePrivilege 

func (c *Client) RevokePrivilege(ctx context.Context, option RevokePrivilegeOption, callOptions ...grpc.CallOption) error

func (*Client) RevokeRole 

func (c *Client) RevokeRole(ctx context.Context, opt RevokeRoleOption, callOpts ...grpc.CallOption) error

func (*Client) RevokeV2 

func (c *Client) RevokeV2(ctx context.Context, option RevokeV2Option, callOptions ...grpc.CallOption) error

func (*Client) Search 

func (c *Client) Search(ctx context.Context, option SearchOption, callOptions ...grpc.CallOption) ([]ResultSet, error)
Example (Basic) 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"
	token := "root:Milvus"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
		APIKey:  token,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	queryVector := []float32{0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592}

	resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
		"quick_setup", // collectionName
		3,             // limit
		[]entity.Vector{entity.FloatVector(queryVector)},
	))
	if err != nil {
		log.Fatal("failed to perform basic ANN search collection: ", err.Error())
	}

	for _, resultSet := range resultSets {
		log.Println("IDs: ", resultSet.IDs)
		log.Println("Scores: ", resultSet.Scores)
	}
}

Output:
Example (Multivectors) 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"
	token := "root:Milvus"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
		APIKey:  token,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	queryVectors := []entity.Vector{
		entity.FloatVector([]float32{0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592}),
		entity.FloatVector([]float32{0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104}),
	}

	resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
		"quick_setup", // collectionName
		3,             // limit
		queryVectors,
	))
	if err != nil {
		log.Fatal("failed to perform basic ANN search collection: ", err.Error())
	}

	for _, resultSet := range resultSets {
		log.Println("IDs: ", resultSet.IDs)
		log.Println("Scores: ", resultSet.Scores)
	}
}

Output:
Example (OffsetLimit) 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"
	token := "root:Milvus"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
		APIKey:  token,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	queryVector := []float32{0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592}

	resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
		"quick_setup", // collectionName
		3,             // limit
		[]entity.Vector{entity.FloatVector(queryVector)},
	).WithOffset(10))
	if err != nil {
		log.Fatal("failed to perform basic ANN search collection: ", err.Error())
	}

	for _, resultSet := range resultSets {
		log.Println("IDs: ", resultSet.IDs)
		log.Println("Scores: ", resultSet.Scores)
	}
}

Output:
Example (OutputFields) 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"
	token := "root:Milvus"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
		APIKey:  token,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	queryVector := []float32{0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592}

	resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
		"quick_setup", // collectionName
		3,             // limit
		[]entity.Vector{entity.FloatVector(queryVector)},
	).WithOutputFields("color"))
	if err != nil {
		log.Fatal("failed to perform basic ANN search collection: ", err.Error())
	}

	for _, resultSet := range resultSets {
		log.Println("IDs: ", resultSet.IDs)
		log.Println("Scores: ", resultSet.Scores)
		log.Println("Colors: ", resultSet.GetColumn("color"))
	}
}

Output:
Example (Partition) 
package main

import (
	"context"
	"log"

	"github.com/milvus-io/milvus/client/v2/entity"
	"github.com/milvus-io/milvus/client/v2/milvusclient"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	milvusAddr := "127.0.0.1:19530"
	token := "root:Milvus"

	cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
		Address: milvusAddr,
		APIKey:  token,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus server: ", err.Error())
	}

	defer cli.Close(ctx)

	queryVector := []float32{0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592}

	resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
		"quick_setup", // collectionName
		3,             // limit
		[]entity.Vector{entity.FloatVector(queryVector)},
	).WithPartitions("partitionA"))
	if err != nil {
		log.Fatal("failed to perform basic ANN search collection: ", err.Error())
	}

	for _, resultSet := range resultSets {
		log.Println("IDs: ", resultSet.IDs)
		log.Println("Scores: ", resultSet.Scores)
	}
}

Output:

func (*Client) TransferReplica 

func (c *Client) TransferReplica(ctx context.Context, opt TransferReplicaOption, callOptions ...grpc.CallOption) error

func (*Client) UpdatePassword 

func (c *Client) UpdatePassword(ctx context.Context, opt UpdatePasswordOption, callOpts ...grpc.CallOption) error

func (*Client) UpdateResourceGroup 

func (c *Client) UpdateResourceGroup(ctx context.Context, opt UpdateResourceGroupOption, callOptions ...grpc.CallOption) error

func (*Client) Upsert 

func (c *Client) Upsert(ctx context.Context, option UpsertOption, callOptions ...grpc.CallOption) (UpsertResult, error)

func (*Client) UseDatabase 

func (c *Client) UseDatabase(ctx context.Context, option UseDatabaseOption) error

type ClientConfig 

type ClientConfig struct {
	Address  string // Remote address, "localhost:19530".
	Username string // Username for auth.
	Password string // Password for auth.
	DBName   string // DBName for this client.

	EnableTLSAuth bool   // Enable TLS Auth for transport security.
	APIKey        string // API key

	DialOptions []grpc.DialOption // Dial options for GRPC.

	RetryRateLimit *RetryRateLimitOption // option for retry on rate limit inteceptor

	DisableConn bool

	ServerVersion string // ServerVersion
	// contains filtered or unexported fields
}

ClientConfig for milvus client.

type CollectionCache 

type CollectionCache struct {
	// contains filtered or unexported fields
}

CollectionCache stores the cached collection schema information.

func NewCollectionCache 

func NewCollectionCache(fetcher func(context.Context, string) (*entity.Collection, error)) *CollectionCache

func (*CollectionCache) GetCollection 

func (c *CollectionCache) GetCollection(ctx context.Context, collName string) (*entity.Collection, error)

func (*CollectionCache) Reset 

func (c *CollectionCache) Reset()

Reset clears all cached info, used when client switching env.

type CompactOption 

type CompactOption interface {
	Request() *milvuspb.ManualCompactionRequest
}

type CreateAliasOption 

type CreateAliasOption interface {
	Request() *milvuspb.CreateAliasRequest
}

CreateCollectionOption is the interface builds CreateAliasRequest.

type CreateCollectionOption 

type CreateCollectionOption interface {
	// Request is the method returns the composed request.
	Request() *milvuspb.CreateCollectionRequest
	// Indexes is the method returns IndexOption to create
	Indexes() []CreateIndexOption
	IsFast() bool
}

CreateCollectionOption is the interface builds CreateCollectionRequest.

type CreateDatabaseOption 

type CreateDatabaseOption interface {
	Request() *milvuspb.CreateDatabaseRequest
}

type CreateIndexOption 

type CreateIndexOption interface {
	Request() *milvuspb.CreateIndexRequest
}

type CreateIndexTask 

type CreateIndexTask struct {
	// contains filtered or unexported fields
}

func (*CreateIndexTask) Await 

func (t *CreateIndexTask) Await(ctx context.Context) error

type CreatePartitionOption 

type CreatePartitionOption interface {
	// Request is the method returns the composed request.
	Request() *milvuspb.CreatePartitionRequest
}

CreatePartitionOption is the interface builds Create Partition request.

type CreatePrivilegeGroupOption 

type CreatePrivilegeGroupOption interface {
	Request() *milvuspb.CreatePrivilegeGroupRequest
}

CreatePrivilegeGroupOption is the interface builds CreatePrivilegeGroupRequest

type CreateResourceGroupOption 

type CreateResourceGroupOption interface {
	Request() *milvuspb.CreateResourceGroupRequest
}

type CreateRoleOption 

type CreateRoleOption interface {
	Request() *milvuspb.CreateRoleRequest
}

type CreateUserOption 

type CreateUserOption interface {
	Request() *milvuspb.CreateCredentialRequest
}

type DataSet 

type DataSet []column.Column

DataSet is an alias type for column slice. Returned by query API.

func (DataSet) Len 

func (ds DataSet) Len() int

Len returns the row count of dataset. if there is no column, it shall return 0.

func (DataSet) Unmarshal 

func (ds DataSet) Unmarshal(receiver any) (err error)

Unmarshal puts dataset into receiver in row based way. `receiver` shall be a slice of pointer of model struct eg, []*Records, in which type `Record` defines the row data.

type DeleteOption 

type DeleteOption interface {
	Request() *milvuspb.DeleteRequest
}

type DeleteResult 

type DeleteResult struct {
	DeleteCount int64
}

type DescribeAliasOption 

type DescribeAliasOption interface {
	Request() *milvuspb.DescribeAliasRequest
}

DescribeAliasOption is the interface builds DescribeAliasOption.

type DescribeCollectionOption 

type DescribeCollectionOption interface {
	// Request is the method returns the composed request.
	Request() *milvuspb.DescribeCollectionRequest
}

DescribeCollectionOption is the interface builds DescribeCollection request.

type DescribeDatabaseOption 

type DescribeDatabaseOption interface {
	Request() *milvuspb.DescribeDatabaseRequest
}

type DescribeIndexOption 

type DescribeIndexOption interface {
	Request() *milvuspb.DescribeIndexRequest
}

type DescribeResourceGroupOption 

type DescribeResourceGroupOption interface {
	Request() *milvuspb.DescribeResourceGroupRequest
}

type DescribeRoleOption 

type DescribeRoleOption interface {
	Request() *milvuspb.SelectGrantRequest
}

type DescribeUserOption 

type DescribeUserOption interface {
	Request() *milvuspb.SelectUserRequest
}

type DropAliasOption 

type DropAliasOption interface {
	Request() *milvuspb.DropAliasRequest
}

DropAliasOption is the interface builds DropAliasRequest.

type DropCollectionOption 

type DropCollectionOption interface {
	Request() *milvuspb.DropCollectionRequest
}

The DropCollectionOption interface builds DropCollectionRequest.

type DropCollectionPropertiesOption 

type DropCollectionPropertiesOption interface {
	Request() *milvuspb.AlterCollectionRequest
}

type DropDatabaseOption 

type DropDatabaseOption interface {
	Request() *milvuspb.DropDatabaseRequest
}

type DropDatabasePropertiesOption 

type DropDatabasePropertiesOption interface {
	Request() *milvuspb.AlterDatabaseRequest
}

type DropIndexOption 

type DropIndexOption interface {
	Request() *milvuspb.DropIndexRequest
}

type DropPartitionOption 

type DropPartitionOption interface {
	// Request is the method returns the composed request.
	Request() *milvuspb.DropPartitionRequest
}

DropPartitionOption is the interface that builds Drop Partition request.

type DropPrivilegeGroupOption 

type DropPrivilegeGroupOption interface {
	Request() *milvuspb.DropPrivilegeGroupRequest
}

DropPrivilegeGroupOption is the interface builds DropPrivilegeGroupRequest

type DropResourceGroupOption 

type DropResourceGroupOption interface {
	Request() *milvuspb.DropResourceGroupRequest
}

type DropRoleOption 

type DropRoleOption interface {
	Request() *milvuspb.DropRoleRequest
}

type DropUserOption 

type DropUserOption interface {
	Request() *milvuspb.DeleteCredentialRequest
}

type FlushOption 

type FlushOption interface {
	Request() *milvuspb.FlushRequest
	CollectionName() string
	CheckInterval() time.Duration
}

type FlushTask 

type FlushTask struct {
	// contains filtered or unexported fields
}

func (*FlushTask) Await 

func (t *FlushTask) Await(ctx context.Context) error

func (*FlushTask) GetFlushStats 

func (t *FlushTask) GetFlushStats() (segIDs []int64, flushSegIDs []int64, flushTs uint64, channelCheckpoints map[string]*msgpb.MsgPosition)

type GetCollectionOption 

type GetCollectionOption interface {
	Request() *milvuspb.GetCollectionStatisticsRequest
}

type GetCompactionStateOption 

type GetCompactionStateOption interface {
	Request() *milvuspb.GetCompactionStateRequest
}

type GetLoadStateOption 

type GetLoadStateOption interface {
	Request() *milvuspb.GetLoadStateRequest
	ProgressRequest() *milvuspb.GetLoadingProgressRequest
}

type GetPartitionStatsOption 

type GetPartitionStatsOption interface {
	Request() *milvuspb.GetPartitionStatisticsRequest
}

type GetPersistentSegmentInfoOption 

type GetPersistentSegmentInfoOption interface {
	Request() *milvuspb.GetPersistentSegmentInfoRequest
}

func NewGetPersistentSegmentInfoOption 

func NewGetPersistentSegmentInfoOption(collectionName string) GetPersistentSegmentInfoOption

type GetServerVersionOption 

type GetServerVersionOption interface {
	Request() *milvuspb.GetVersionRequest
}

GetServerVersionOption is the interface for GetServerVersion request.

type GrantPrivilegeOption 

type GrantPrivilegeOption interface {
	Request() *milvuspb.OperatePrivilegeRequest
}

type GrantRoleOption 

type GrantRoleOption interface {
	Request() *milvuspb.OperateUserRoleRequest
}

type GrantV2Option 

type GrantV2Option interface {
	Request() *milvuspb.OperatePrivilegeV2Request
}

GrantV2Option is the interface builds OperatePrivilegeV2Request

type HasCollectionOption 

type HasCollectionOption interface {
	Request() *milvuspb.DescribeCollectionRequest
}

HasCollectionOption is the interface to build DescribeCollectionRequest.

func NewHasCollectionOption 

func NewHasCollectionOption(name string) HasCollectionOption

type HasPartitionOption 

type HasPartitionOption interface {
	// Request is the method returns the composed request.
	Request() *milvuspb.HasPartitionRequest
}

HasPartitionOption is the interface builds HasPartition request.

type HybridSearchOption 

type HybridSearchOption interface {
	HybridRequest() (*milvuspb.HybridSearchRequest, error)
}

type IndexDescription 

type IndexDescription struct {
	index.Index
	State            index.IndexState
	PendingIndexRows int64
	TotalRows        int64
	IndexedRows      int64
}

type InsertOption 

type InsertOption interface {
	InsertRequest(coll *entity.Collection) (*milvuspb.InsertRequest, error)
	CollectionName() string
	WriteBackPKs(schema *entity.Schema, pks column.Column) error
}

type InsertResult 

type InsertResult struct {
	InsertCount int64
	IDs         column.Column
}

type ListAliasesOption 

type ListAliasesOption interface {
	Request() *milvuspb.ListAliasesRequest
}

ListAliasesOption is the interface builds ListAliasesRequest.

type ListCollectionOption 

type ListCollectionOption interface {
	Request() *milvuspb.ShowCollectionsRequest
}

type ListDatabaseOption 

type ListDatabaseOption interface {
	Request() *milvuspb.ListDatabasesRequest
}

ListDatabaseOption is a builder interface for ListDatabase request.

type ListIndexOption 

type ListIndexOption interface {
	Request() *milvuspb.DescribeIndexRequest
	Matches(*milvuspb.IndexDescription) bool
}

type ListPartitionsOption 

type ListPartitionsOption interface {
	// Request is the method returns the composed request.
	Request() *milvuspb.ShowPartitionsRequest
}

ListPartitionsOption is the interface builds List Partition request.

type ListPrivilegeGroupsOption 

type ListPrivilegeGroupsOption interface {
	Request() *milvuspb.ListPrivilegeGroupsRequest
}

ListPrivilegeGroupsOption is the interface builds ListPrivilegeGroupsRequest

type ListResourceGroupsOption 

type ListResourceGroupsOption interface {
	Request() *milvuspb.ListResourceGroupsRequest
}

type ListRoleOption 

type ListRoleOption interface {
	Request() *milvuspb.SelectRoleRequest
}

type ListUserOption 

type ListUserOption interface {
	Request() *milvuspb.ListCredUsersRequest
}

type LoadCollectionOption 

type LoadCollectionOption interface {
	Request() *milvuspb.LoadCollectionRequest
	CheckInterval() time.Duration
	IsRefresh() bool
}

type LoadPartitionsOption 

type LoadPartitionsOption interface {
	Request() *milvuspb.LoadPartitionsRequest
	CheckInterval() time.Duration
	IsRefresh() bool
}

type LoadTask 

type LoadTask struct {
	// contains filtered or unexported fields
}

func (*LoadTask) Await 

func (t *LoadTask) Await(ctx context.Context) error

type OperatePrivilegeGroupOption 

type OperatePrivilegeGroupOption interface {
	Request() *milvuspb.OperatePrivilegeGroupRequest
}

OperatePrivilegeGroupOption is the interface builds OperatePrivilegeGroupRequest

type QueryOption 

type QueryOption interface {
	Request() (*milvuspb.QueryRequest, error)
}

type RefreshLoadOption 

type RefreshLoadOption interface {
	Request() *milvuspb.LoadCollectionRequest
	CheckInterval() time.Duration
}

type ReleaseCollectionOption 

type ReleaseCollectionOption interface {
	Request() *milvuspb.ReleaseCollectionRequest
}

type ReleasePartitionsOption 

type ReleasePartitionsOption interface {
	Request() *milvuspb.ReleasePartitionsRequest
}

type RenameCollectionOption 

type RenameCollectionOption interface {
	Request() *milvuspb.RenameCollectionRequest
}

type Reranker 

type Reranker interface {
	GetParams() []*commonpb.KeyValuePair
}

type RestoreRBACOption 

type RestoreRBACOption interface {
	Request() *milvuspb.RestoreRBACMetaRequest
}

func NewRestoreRBACOption 

func NewRestoreRBACOption(meta *entity.RBACMeta) RestoreRBACOption

type ResultSet 

type ResultSet struct {
	ResultCount  int // the returning entry count
	GroupByValue column.Column
	IDs          column.Column // auto generated id, can be mapped to the columns from `Insert` API
	Fields       DataSet       // output field data
	Scores       []float32     // distance to the target vector
	Recall       float32       // recall of the query vector's search result (estimated by zilliz cloud)
	Err          error         // search error if any
	// contains filtered or unexported fields
}

ResultSet is struct for search result set.

func (*ResultSet) GetColumn 

func (rs *ResultSet) GetColumn(fieldName string) column.Column

GetColumn returns column with provided field name.

func (*ResultSet) Unmarshal 

func (sr *ResultSet) Unmarshal(receiver any) (err error)

Unmarshal puts dataset into receiver in row based way. `receiver` shall be a slice of pointer of model struct eg, []*Records, in which type `Record` defines the row data. note that distance/score is not unmarshaled here.

type RetryRateLimitOption 

type RetryRateLimitOption struct {
	MaxRetry   uint
	MaxBackoff time.Duration
}

type RevokePrivilegeOption 

type RevokePrivilegeOption interface {
	Request() *milvuspb.OperatePrivilegeRequest
}

type RevokeRoleOption 

type RevokeRoleOption interface {
	Request() *milvuspb.OperateUserRoleRequest
}

type RevokeV2Option 

type RevokeV2Option interface {
	Request() *milvuspb.OperatePrivilegeV2Request
}

RevokeV2Option is the interface builds OperatePrivilegeV2Request

type SearchOption 

type SearchOption interface {
	Request() (*milvuspb.SearchRequest, error)
}

type TransferReplicaOption 

type TransferReplicaOption interface {
	Request() *milvuspb.TransferReplicaRequest
}

type UpdatePasswordOption 

type UpdatePasswordOption interface {
	Request() *milvuspb.UpdateCredentialRequest
}

type UpdateResourceGroupOption 

type UpdateResourceGroupOption interface {
	Request() *milvuspb.UpdateResourceGroupsRequest
}

type UpsertOption 

type UpsertOption interface {
	UpsertRequest(coll *entity.Collection) (*milvuspb.UpsertRequest, error)
	CollectionName() string
}

type UpsertResult 

type UpsertResult struct {
	UpsertCount int64
	IDs         column.Column
}

type UseDatabaseOption 

type UseDatabaseOption interface {
	DbName() string
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.