mongo

package
v1.0.11 Latest Latest
Warning

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

 Go to latest Published: Dec 2, 2022 License: MIT Imports: 11 Imported by: 0

Documentation

Overview

Package mongo provides functionality for measuring and displaying time.

The calendrical calculations always assume a Gregorian calendar, with no leap seconds.

Monotonic Clocks

Operating systems provide both a “wall clock,” which is subject to changes for clock synchronization, and a “monotonic clock,” which is not. The general rule is that the wall clock is for telling time and the monotonic clock is for measuring time. Rather than split the API, in this package the Time returned by time.Now contains both a wall clock reading and a monotonic clock reading; later time-telling operations use the wall clock reading, but later time-measuring operations, specifically comparisons and subtractions, use the monotonic clock reading.

Index

Examples

Constants

This section is empty.

Variables

View Source 
var Client *mongo.Client

Functions

func Disconnect 

func Disconnect()

func Divide 

func Divide(values []any) bson.D

func DivideField 

func DivideField(field string, values []any) bson.D

func Eq 

func Eq(value any) bson.D

func EqField 

func EqField(field string, value any) bson.D

func Exists 

func Exists(value bool) bson.D

func ExistsField 

func ExistsField(field string, value bool) bson.D

func Expr 

func Expr(values []any) bson.D

func ExprField 

func ExprField(operator string, values []any) bson.D

func GetCollection 

func GetCollection(database string, collectionName string) *mongo.Collection

func Gt 

func Gt(value any) bson.D

func GtField 

func GtField(field string, value any) bson.D

func Gte 

func Gte(value any) bson.D

func GteField 

func GteField(field string, value any) bson.D

func In 

func In(values []any) bson.D

func InField 

func InField(field string, values []any) bson.D

func Lt 

func Lt(value any) bson.D

func LtField 

func LtField(field string, value any) bson.D

func Lte 

func Lte(value any) bson.D

func LteField 

func LteField(field string, value any) bson.D

func Ne 

func Ne(value any) bson.D

func NeField 

func NeField(field string, value any) bson.D

func NewClient 

func NewClient() *mongo.Client

func Nin 

func Nin(values []any) bson.D

func NinField 

func NinField(field string, values []any) bson.D

func Not 

func Not(value any) bson.D

func NotField 

func NotField(field string, value bson.D) bson.D

func Regex 

func Regex(value any) bson.D

func RegexField 

func RegexField(field string, regex any, options string) bson.D

func RegexOption 

func RegexOption(value any, options string) bson.D

func Sort 

func Sort(field string, asc bool) bson.D

func Type 

func Type(value string) bson.D

func TypeField 

func TypeField(field string, value string) bson.D

Types

type DataLog 

type DataLog struct {
	Action       string
	SaveChange   bool
	SaveHistory  bool
	SaveInfo     bool
	SaveAnalytic bool
	Info         InfoModel
}

type DataResult 

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

func DeleteMany 

func DeleteMany(param DeleteInterface) DataResult
Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"
	"time"
)

func main() {
	start := time.Now()

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo", "bolax", "bola.azul"},
	}

	deleteParams := mongo.DeleteParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		FindParams: findParams,
		DataLog: mongo.DataLog{
			Action:       "INSERT_NSERLUM",
			SaveHistory:  true,
			SaveInfo:     false,
			SaveAnalytic: false,
		},
	}
	dataResult := mongo.DeleteMany(deleteParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//insertResult.toAPI()

	fmt.Println("id--->>>", dataResult.Id, time.Since(start))
	fmt.Println("insertResult--->>>", model, time.Since(start))
	fmt.Println("insertResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func DeleteOne 

func DeleteOne(param DeleteInterface) DataResult
Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"
	"time"
)

func main() {
	start := time.Now()

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo", "bolax", "bola.azul"},
	}

	deleteParams := mongo.DeleteParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		FindParams: findParams,
		DataLog: mongo.DataLog{
			Action:       "INSERT_NSERLUM",
			SaveHistory:  true,
			SaveInfo:     false,
			SaveAnalytic: false,
		},
	}
	dataResult := mongo.DeleteOne(deleteParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//insertResult.toAPI()

	fmt.Println("id--->>>", dataResult.Id, time.Since(start))
	fmt.Println("insertResult--->>>", model, time.Since(start))
	fmt.Println("insertResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func Find 

func Find(param FindParams) DataResult

Find executa um comando find e retorna um 'DataResult' contendo um único documento da coleção.

O parâmetro do 'filter' deve ser um 'MongoFilter' contendo operadores de consulta e pode ser usado para selecionar o documento a ser retornado. Não pode ser nulo. Se o 'filter' não corresponder a nenhum documento, será retornado um 'DataResult' com um erro definido como ErrNoDocuments. Se 'filter' corresponder a vários documentos, o primeiro documento da lista um será selecionado do conjunto correspondente e retornado.

O parâmetro 'options' deve ser um 'FindOptions' e pode ser usado para especificar opções para esta operação (consulte a documentação options.FindOneOptions).

Para obter mais informações sobre o comando, consulte https://www.mongodb.com/docs/manual/reference/command/find/ .

Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"
	"time"
)

func main() {
	start := time.Now()

	filter := mongo.NewFilter()
	filter.Add("quantity", mongo.Gte(20))

	//db.inventory.find( { quantity: { $gte: 20 } } )
	//db.inventory.find(bson.D{bson.E{Key: "quantity", Value: bson.E{Key: "$gte", Value: 20}}})

	//filter.Id("6384f0e452ed0e02aa02d688")
	//filter.Add("nserlum", db.Eq(654321))
	//filter.Add("status", db.Eq(true))
	//filter.Add("nserlum", db.Gt(500000))
	//filter.Add("nserlum", db.Gte(500000))
	//filter.Add("nserlum", db.Lt(500000))
	//filter.Add("nserlum", db.Lte(500000))
	//filter.Add("nserlum", db.Ne(123456))
	//filter.Add("nserlum", db.In([]any{654321}))
	//filter.Add("nserlum", db.Nin([]any{654321}))
	//filter.Add("nserlum", db.Exists(true))
	///???filter.Add("gato", db.Type("amarelo"))
	//filter.Add("gato", db.Regex("v.rd+"))

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Filter:     filter,
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo", "gato", "nserlum", "Opa"},
		Options: mongo.FindOptions{
			Sort: mongo.Sort("etiqueta", false),
		},
	}
	dataResult := mongo.Find(findParams)

	var models []mongo.FdibModel
	dataResult.Print()
	dataResult.Models(&models)

	//dataResult.toAPI()
	fmt.Println("dataResult--->>>", models, time.Since(start))
	//fmt.Println("dataResult--->>>", model, time.Since(start))
	//fmt.Println("dataResult--->>>", models[1].Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func FindOne 

func FindOne(param FindParams) DataResult

FindOne executa um comando find e retorna um 'DataResult' contendo um único documento da coleção.

O parâmetro do 'filter' deve ser um 'MongoFilter' contendo operadores de consulta e pode ser usado para selecionar o documento a ser retornado. Não pode ser nulo. Se o 'filter' não corresponder a nenhum documento, será retornado um 'DataResult' com um erro definido como ErrNoDocuments. Se 'filter' corresponder a vários documentos, o primeiro documento da lista um será selecionado do conjunto correspondente e retornado.

O parâmetro 'options' deve ser um 'FindOptions' e pode ser usado para especificar opções para esta operação (consulte a documentação options.FindOneOptions).

Para obter mais informações sobre o comando, consulte https://www.mongodb.com/docs/manual/reference/command/find/.

Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"
	"time"
)

func main() {
	start := time.Now()

	filter := mongo.NewFilter()
	//filter.Id("6384f0e452ed0e02aa02d688")
	//filter.Add("nserlum", db.Eq(654321))
	//filter.Add("status", db.Eq(true))
	//filter.Add("nserlum", db.Gt(500000))
	//filter.Add("nserlum", db.Gte(500000))
	//filter.Add("nserlum", db.Lt(500000))
	//filter.Add("nserlum", db.Lte(500000))
	//filter.Add("nserlum", db.Ne(123456))
	//filter.Add("nserlum", db.In([]any{654321}))
	//filter.Add("nserlum", db.Nin([]any{654321}))
	filter.Add("nserlum", mongo.Exists(true))
	///???filter.Add("gato", db.Type("amarelo"))
	//filter.Add("gato", db.Regex("v.rd+"))

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Filter:     filter,
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo", "gato", "nserlum", "Opa"},
		Options:    mongo.FindOptions{},
	}
	dataResult := mongo.FindOne(findParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//dataResult.toAPI()
	fmt.Println("dataResult--->>>", model, time.Since(start))
	fmt.Println("dataResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func FindOneAndUpdate 

func FindOneAndUpdate(param UpdateInterface) DataResult
Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"
	"time"
)

func main() {
	start := time.Now()

	filter := mongo.NewFilter()
	filter.Id("6384f0e452ed0e02aa02d688")

	input := mongo.NewUpdateInput()
	input.Set("nserlum", 999999)
	input.SetMap(map[string]any{
		"bola": "azul",
		"mala": "verde",
	})

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo"},
	}

	updateParams := mongo.UpdateParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Info:       nil,
		Input:      input,
		Filter:     filter,
		FindParams: findParams,
		UpdateOptions: mongo.UpdateOptions{
			ReturnOriginal: true,
			Upsert:         true,
		},
		DataLog: mongo.DataLog{
			Action:       "UPDATE_NSERLUM",
			SaveChange:   true,
			SaveHistory:  true,
			SaveInfo:     false,
			SaveAnalytic: false,
		},
	}
	dataResult := mongo.FindOneAndUpdate(updateParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//insertResult.toAPI()

	fmt.Println("id--->>>", dataResult.Id, time.Since(start))
	fmt.Println("insertResult--->>>", model, time.Since(start))
	fmt.Println("insertResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func InsertMany 

func InsertMany(param InsertInterface) DataResult
Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"

	"time"
)

func main() {
	start := time.Now()
	dataModel := mongo.FdibModel{
		IdPeca:     "78945612",
		ColetaRede: time.Now(),
		Etiqueta:   "IP08526A",
		Nserlum:    654321,
		Status:     true,
		Tempo: mongo.TempoModel{
			LigadoParcial:   time.Now(),
			LigadoDecorrido: time.Now(),
		},
	}

	input := mongo.NewInsertInput()
	input.Model(dataModel)
	input.Data("nserlum", 123456)
	input.DataMap(map[string]any{
		"casa":      1,
		"gato":      "verde",
		"Opa":       1.5,
		"bola.azul": "circular",
		"bolax": map[string]any{
			"azulx": "quadrado",
		},
		"list": []any{"A", "B", "C", 1, 2, 3},
	})

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo", "bolax", "bola.azul"},
	}

	insertParams := mongo.InsertParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Input:      input,
		FindParams: findParams,
		DataLog: mongo.DataLog{
			Action:       "INSERT_NSERLUM",
			SaveHistory:  true,
			SaveInfo:     false,
			SaveAnalytic: false,
		},
	}
	dataResult := mongo.InsertMany(insertParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//insertResult.toAPI()

	fmt.Println("id--->>>", dataResult.Id, time.Since(start))
	fmt.Println("insertResult--->>>", model, time.Since(start))
	fmt.Println("insertResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func InsertOne 

func InsertOne(param InsertInterface) DataResult
Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"

	"time"
)

func main() {
	start := time.Now()
	dataModel := mongo.FdibModel{
		IdPeca:     "78945612",
		ColetaRede: time.Now(),
		Etiqueta:   "IP08526A",
		Nserlum:    654321,
		Status:     true,
		Tempo: mongo.TempoModel{
			LigadoParcial:   time.Now(),
			LigadoDecorrido: time.Now(),
		},
	}

	input := mongo.NewInsertInput()
	input.Model(dataModel)
	input.Data("nserlum", 123456)
	input.DataMap(map[string]any{
		"casa":      1,
		"gato":      "verde",
		"Opa":       1.5,
		"bola.azul": "circular",
		"bolax": map[string]any{
			"azulx": "quadrado",
		},
		"list": []any{"A", "B", "C", 1, 2, 3},
	})

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo", "bolax", "bola.azul"},
	}

	insertParams := mongo.InsertParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Input:      input,
		FindParams: findParams,
		DataLog: mongo.DataLog{
			Action:       "INSERT_NSERLUM",
			SaveHistory:  true,
			SaveInfo:     false,
			SaveAnalytic: false,
		},
	}
	dataResult := mongo.InsertOne(insertParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//insertResult.toAPI()

	fmt.Println("id--->>>", dataResult.Id, time.Since(start))
	fmt.Println("insertResult--->>>", model, time.Since(start))
	fmt.Println("insertResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func UpdateMany 

func UpdateMany(param UpdateInterface) DataResult
Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"
	"time"
)

func main() {
	start := time.Now()

	filter := mongo.NewFilter()
	filter.Id("6384f0e452ed0e02aa02d688")

	input := mongo.NewUpdateInput()
	input.Set("nserlum", 999999)
	input.SetMap(map[string]any{
		"bola": "azul",
		"mala": "verde",
	})

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo"},
	}

	updateParams := mongo.UpdateParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Info:       nil,
		Input:      input,
		Filter:     filter,
		FindParams: findParams,
		UpdateOptions: mongo.UpdateOptions{
			ReturnOriginal: true,
			Upsert:         true,
		},
		DataLog: mongo.DataLog{
			Action:       "UPDATE_NSERLUM",
			SaveChange:   true,
			SaveHistory:  true,
			SaveInfo:     false,
			SaveAnalytic: false,
		},
	}
	dataResult := mongo.UpdateMany(updateParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//insertResult.toAPI()

	fmt.Println("id--->>>", dataResult.Id, time.Since(start))
	fmt.Println("insertResult--->>>", model, time.Since(start))
	fmt.Println("insertResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func UpdateOne 

func UpdateOne(param UpdateInterface) DataResult
Example 
package main

import (
	"fmt"
	"github.com/israelagoeiro/api_connect_core/mongo"
	"time"
)

func main() {
	start := time.Now()

	filter := mongo.NewFilter()
	filter.Id("6384f0e452ed0e02aa02d688")

	input := mongo.NewUpdateInput()
	input.Set("nserlum", 999999)
	input.SetMap(map[string]any{
		"bola": "azul",
		"mala": "verde",
	})

	findParams := mongo.FindParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Fields:     []string{"idPeca", "coletaRede", "etiqueta", "status", "tempo"},
	}

	updateParams := mongo.UpdateParams{
		Collection: "users",
		Connection: "123456abc",
		Database:   "api-kdl-test",
		Info:       nil,
		Input:      input,
		Filter:     filter,
		FindParams: findParams,
		UpdateOptions: mongo.UpdateOptions{
			ReturnOriginal: true,
			Upsert:         true,
		},
		DataLog: mongo.DataLog{
			Action:       "UPDATE_NSERLUM",
			SaveChange:   true,
			SaveHistory:  true,
			SaveInfo:     false,
			SaveAnalytic: false,
		},
	}
	dataResult := mongo.UpdateOne(updateParams)

	model := mongo.FdibModel{}
	dataResult.Model(&model)
	dataResult.Print()
	//insertResult.toAPI()

	fmt.Println("id--->>>", dataResult.Id, time.Since(start))
	fmt.Println("insertResult--->>>", model, time.Since(start))
	fmt.Println("insertResult--->>>", model.Etiqueta, time.Since(start))

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func (DataResult) API 

func (u DataResult) API() []string

func (DataResult) Id 

func (u DataResult) Id()

func (DataResult) Ids 

func (u DataResult) Ids()

func (DataResult) Model 

func (u DataResult) Model(model interface{})

func (DataResult) Models 

func (u DataResult) Models(models interface{})

func (DataResult) Print 

func (u DataResult) Print()

func (DataResult) Result 

func (u DataResult) Result() interface{}

func (DataResult) TotalAfected 

func (u DataResult) TotalAfected() int

type DeleteDocument added in v1.0.8 

type DeleteDocument struct {
	DeleteMany func() DataResult
	DeleteOne  func() DataResult
}

func NewDeleteDocument added in v1.0.8 

func NewDeleteDocument(param DeleteParams) DeleteDocument

type DeleteInterface 

type DeleteInterface interface {
	// contains filtered or unexported methods
}

DeleteInterface reune comandos de exclusão

type DeleteParams 

type DeleteParams struct {
	Collection string
	Connection string
	Database   string
	DataLog    DataLog
	FindParams FindParams
	Filter     MongoFilter
}

type DocumentInsert 

type DocumentInsert struct {
	InsertMany func() DataResult
	InsertOne  func() DataResult
}

func NewDocumentInsert 

func NewDocumentInsert(param InsertParams) DocumentInsert

type FdibModel added in v1.0.11 

type FdibModel struct {
	IdPeca     string     `json:"idPeca" bson:"idPeca"`
	Nserlum    int        `json:"nserlum" bson:"nserlum"`
	ColetaRede time.Time  `json:"coletaRede" bson:"coletaRede"`
	Etiqueta   string     `json:"etiqueta" bson:"etiqueta"`
	Status     bool       `json:"status" bson:"status"`
	Tempo      TempoModel `json:"tempo" bson:"tempo"`
}

type Fields 

type Fields struct {
	Values func() bson.D
}

func NewFields 

func NewFields(listFields []string) Fields

type FindDocument added in v1.0.8 

type FindDocument struct {
	Find    func() DataResult
	FindOne func() DataResult
}

func NewFindDocument added in v1.0.8 

func NewFindDocument(param FindParams) FindDocument

type FindInterface 

type FindInterface interface {
	// contains filtered or unexported methods
}

FindInterface reune comandos de consulta

type FindOptions 

type FindOptions struct {
	Sort bson.D
}

type FindParams 

type FindParams struct {
	Collection string
	Connection string
	Database   string
	Filter     MongoFilter
	Fields     []string
	Options    FindOptions
}

type HistoryModel 

type HistoryModel struct {
	Checksum  string    `json:"cks" bson:"cks"`
	CreatedAt time.Time `json:"createdAt" bson:"createdAt"`
	Action    string    `json:"action" bson:"action"`
	Owner     string    `json:"owner" bson:"owner"`
}

type InfoModel 

type InfoModel struct {
	ChangedAt time.Time       `json:"changedAt" bson:"changedAt"`
	CreatedAt time.Time       `json:"createdAt" bson:"createdAt"`
	Checksum  string          `json:"cks" bson:"cks"`
	Owner     string          `json:"owner" bson:"owner"`
	Version   int             `json:"v" bson:"v"`
	History   *[]HistoryModel `json:"history,omitempty" bson:"history,omitempty"`
}

type InsertInput 

type InsertInput struct {
	Model   func(values any)
	Data    func(field string, values any)
	DataMap func(values map[string]any)
	IsValid func() bool
	Values  func() bson.D
}

func NewInsertInput 

func NewInsertInput() InsertInput

type InsertInterface 

type InsertInterface interface {
	// contains filtered or unexported methods
}

InsertInterface reune comandos de inserção

type InsertParams 

type InsertParams struct {
	Collection string
	Connection string
	Database   string
	DataLog    DataLog
	Input      InsertInput
	FindParams FindParams
}

type MongoDataLog 

type MongoDataLog struct {
	PrepareInsert func(input InsertInput)
	PrepareUpdate func(input UpdateInput)
}

func NewMongoDataLog 

func NewMongoDataLog(dataLog DataLog) MongoDataLog

type MongoFilter 

type MongoFilter struct {
	Id       func(value string)
	ObjectId func(value primitive.ObjectID)
	Add      func(field string, operator bson.D)
	Expr     func(operator bson.D)
	Regex    func(field string, operator bson.D)
	And      func(operator []any)
	Nor      func(operator []any)
	Or       func(operator []any)
	Values   func() bson.D
	Debug    func()
}

func NewFilter 

func NewFilter() MongoFilter

type TempoModel added in v1.0.11 

type TempoModel struct {
	LigadoParcial   time.Time `json:"ligadoParcial" bson:"ligadoParcial"`
	LigadoDecorrido time.Time `json:"ligadoDecorrido" bson:"ligadoDecorrido"`
}

type UpdateDocument added in v1.0.8 

type UpdateDocument struct {
	UpdateOne        func() DataResult
	UpdateMany       func() DataResult
	FindOneAndUpdate func() DataResult
}

func NewUpdateDocument added in v1.0.8 

func NewUpdateDocument(param UpdateParams) UpdateDocument

type UpdateInput 

type UpdateInput struct {
	AddToSet    func(field string, value any)
	AddToSetMap func(values map[string]any)
	Inc         func(field string, value any)
	IncMap      func(values map[string]any)
	Set         func(field string, value any)
	SetMap      func(values map[string]any)
	IsValid     func() bool
	Values      func() bson.D
}

func NewUpdateInput 

func NewUpdateInput() UpdateInput

type UpdateInterface 

type UpdateInterface interface {
	// contains filtered or unexported methods
}

UpdateInterface reune comandos de exclusão

type UpdateOptions 

type UpdateOptions struct {
	ReturnOriginal bool
	Upsert         bool
}

type UpdateParams 

type UpdateParams struct {
	Collection    string
	Connection    string
	Database      string
	DataLog       DataLog
	Fields        []string
	Filter        MongoFilter
	FindParams    FindParams
	Info          any
	Input         UpdateInput
	UpdateOptions UpdateOptions
}

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.