package physicalplan

Import Path
	github.com/polarsignals/frostdb/query/physicalplan (on go.dev)

Dependency Relation
	imports 30 packages, and imported by one package

Involved Source Files

	    aggregate.go
	    binaryscalarexpr.go
	    distinct.go
	    filter.go
	    limit.go
	    ordered_aggregate.go
	    ordered_synchronizer.go
	    physicalplan.go
	    planordering.go
	    project.go
	    regexpfilter.go
	    sampler.go
	    synchronize.go
Package-Level Type Names (total 36)

	/* sort by: alphabet | popularity */
	 type Aggregation (struct)
		Aggregation groups together some lower level primitives to for the column to be aggregated by its function.

		As Inputs Of (at least 2)
			func NewHashAggregate(pool memory.Allocator, tracer trace.Tracer, aggregations []Aggregation, groupByColumnMatchers []logicalplan.Expr, seed maphash.Seed, finalStage bool) *HashAggregate
			func NewOrderedAggregate(pool memory.Allocator, tracer trace.Tracer, aggregation Aggregation, groupByColumnMatchers []logicalplan.Expr, finalStage bool) *OrderedAggregate

	 type AggregationFunction (interface)

		Methods (only one)
			( AggregationFunction) Aggregate(pool memory.Allocator, arrs []arrow.Array) (arrow.Array, error)
		Implemented By (at least 6)
			*AndAggregation
			*CountAggregation
			*MaxAggregation
			*MinAggregation
			*SumAggregation
			*UniqueAggregation

	 type AndAggregation (struct)

		Methods (only one)
			(*AndAggregation) Aggregate(pool memory.Allocator, arrs []arrow.Array) (arrow.Array, error)
		Implements (at least one exported)
			*AndAggregation : AggregationFunction

	 type AndExpr (struct)

		Fields (total 2)
			Left BooleanExpression
			Right BooleanExpression
		Methods (total 2)
			(*AndExpr) Eval(r arrow.Record) (*Bitmap, error)
			(*AndExpr) String() string
		Implements (at least 3)
			*AndExpr : BooleanExpression
			*AndExpr : expvar.Var
			*AndExpr : fmt.Stringer

	 type ArrayRef (struct)

		Fields (only one)
			ColumnName string
		Methods (total 2)
			(*ArrayRef) ArrowArray(r arrow.Record) (arrow.Array, bool, error)
			(*ArrayRef) String() string
		Implements (at least 2)
			*ArrayRef : expvar.Var
			*ArrayRef : fmt.Stringer

	 type ArrayReference (struct)
	 type BinaryScalarExpr (struct)

		Fields (total 3)
			Left *ArrayRef
			Op logicalplan.Op
			Right scalar.Scalar
		Methods (total 2)
			( BinaryScalarExpr) Eval(r arrow.Record) (*Bitmap, error)
			( BinaryScalarExpr) String() string
		Implements (at least 3)
			 BinaryScalarExpr : BooleanExpression
			 BinaryScalarExpr : expvar.Var
			 BinaryScalarExpr : fmt.Stringer

	 type Bitmap = roaring.Bitmap (struct)
	 type BooleanExpression (interface)

		Methods (total 2)
			( BooleanExpression) Eval(r arrow.Record) (*Bitmap, error)
			( BooleanExpression) String() string
		Implemented By (at least 4)
			*AndExpr
			 BinaryScalarExpr
			*OrExpr
			*RegExpFilter
		Implements (at least 2)
			 BooleanExpression : expvar.Var
			 BooleanExpression : fmt.Stringer

	 type CountAggregation (struct)

		Methods (only one)
			(*CountAggregation) Aggregate(pool memory.Allocator, arrs []arrow.Array) (arrow.Array, error)
		Implements (at least one exported)
			*CountAggregation : AggregationFunction

	 type Diagram (struct)

		Fields (total 2)
			Child *Diagram
			Details string
		Methods (only one)
			(*Diagram) String() string
		Implements (at least 2)
			*Diagram : expvar.Var
			*Diagram : fmt.Stringer
		As Outputs Of (at least 14)
			func (*Distinction).Draw() *Diagram
			func (*HashAggregate).Draw() *Diagram
			func (*Limiter).Draw() *Diagram
			func (*OrderedAggregate).Draw() *Diagram
			func (*OrderedSynchronizer).Draw() *Diagram
			func (*OutputPlan).Draw() *Diagram
			func PhysicalPlan.Draw() *Diagram
			func (*PredicateFilter).Draw() *Diagram
			func (*Projection).Draw() *Diagram
			func (*ReservoirSampler).Draw() *Diagram
			func ScanPhysicalPlan.Draw() *Diagram
			func (*SchemaScan).Draw() *Diagram
			func (*Synchronizer).Draw() *Diagram
			func (*TableScan).Draw() *Diagram

	 type Distinction (struct)

		Methods (total 5)
			(*Distinction) Callback(ctx context.Context, r arrow.Record) error
			(*Distinction) Close()
			(*Distinction) Draw() *Diagram
			(*Distinction) Finish(ctx context.Context) error
			(*Distinction) SetNext(plan PhysicalPlan)
		Implements (at least one exported)
			*Distinction : PhysicalPlan
		As Outputs Of (at least one exported)
			func Distinct(pool memory.Allocator, tracer trace.Tracer, columns []logicalplan.Expr) *Distinction

	 type HashAggregate (struct)

		Methods (total 5)
			(*HashAggregate) Callback(_ context.Context, r arrow.Record) error
			(*HashAggregate) Close()
			(*HashAggregate) Draw() *Diagram
			(*HashAggregate) Finish(ctx context.Context) error
			(*HashAggregate) SetNext(next PhysicalPlan)
		Implements (at least one exported)
			*HashAggregate : PhysicalPlan
		As Outputs Of (at least one exported)
			func NewHashAggregate(pool memory.Allocator, tracer trace.Tracer, aggregations []Aggregation, groupByColumnMatchers []logicalplan.Expr, seed maphash.Seed, finalStage bool) *HashAggregate

	 type IndexRange (struct)

		Fields (total 2)
			End uint32
			Start uint32

	 type Limiter (struct)

		Methods (total 5)
			(*Limiter) Callback(ctx context.Context, r arrow.Record) error
			(*Limiter) Close()
			(*Limiter) Draw() *Diagram
			(*Limiter) Finish(ctx context.Context) error
			(*Limiter) SetNext(next PhysicalPlan)
		Implements (at least one exported)
			*Limiter : PhysicalPlan
		As Outputs Of (at least one exported)
			func Limit(pool memory.Allocator, tracer trace.Tracer, expr logicalplan.Expr) (*Limiter, error)

	 type MaxAggregation (struct)

		Methods (only one)
			(*MaxAggregation) Aggregate(pool memory.Allocator, arrs []arrow.Array) (arrow.Array, error)
		Implements (at least one exported)
			*MaxAggregation : AggregationFunction

	 type MinAggregation (struct)

		Methods (only one)
			(*MinAggregation) Aggregate(pool memory.Allocator, arrs []arrow.Array) (arrow.Array, error)
		Implements (at least one exported)
			*MinAggregation : AggregationFunction

	 type Option (func)

		As Outputs Of (at least 3)
			func WithOrderedAggregations() Option
			func WithOverrideInput(input []PhysicalPlan) Option
			func WithReadMode(m logicalplan.ReadMode) Option
		As Inputs Of (at least one exported)
			func Build(ctx context.Context, pool memory.Allocator, tracer trace.Tracer, s *dynparquet.Schema, plan *logicalplan.LogicalPlan, options ...Option) (*OutputPlan, error)

	 type OrderedAggregate (struct)
		OrderedAggregate is an aggregation operator that supports aggregations on
		streams of data ordered by the group by columns. This is a more efficient
		aggregation than aggregating by hash since a group can be determined as
		completed once a different aggregation key is found in the ordered stream.
		OrderedAggregate also supports partially ordered aggregations. This means
		aggregating on keys that arrive in ordered sets of data that are not mutually
		exclusive. For example consider the group by columns: a, a, b, c, a, b, c.
		The OrderedAggregate will perform the aggregation on the first ordered set
		a, a, b, c and another one on the second a, b, c. The result of both
		aggregations is merged. Specifically, if the example is pushed to Callback
		in two records (a, a, b, c) followed by (a, b, c), and assuming that the
		aggregation values for each row are 1 for simplicity and we're using a sum
		aggregation, after the first call to Callback the OrderedAggregate will store
		[a, b, c], [2, 1, 1] but not emit anything. When the second record is pushed,
		the OrderedAggregate will realize that the first value in the new record (a)
		sorts before the "current group" (c), so will store the aggregation results
		of the second record as another ordered group [a, b, c], [1, 1, 1]. Only when
		Finish is called, will the OrderedAggregate be able to emit the merged
		aggregation results. The merged results should be: [a, b, c], [3, 2, 2].

		Methods (total 5)
			(*OrderedAggregate) Callback(_ context.Context, r arrow.Record) error
			(*OrderedAggregate) Close()
			(*OrderedAggregate) Draw() *Diagram
			(*OrderedAggregate) Finish(ctx context.Context) error
			(*OrderedAggregate) SetNext(next PhysicalPlan)
		Implements (at least one exported)
			*OrderedAggregate : PhysicalPlan
		As Outputs Of (at least one exported)
			func NewOrderedAggregate(pool memory.Allocator, tracer trace.Tracer, aggregation Aggregation, groupByColumnMatchers []logicalplan.Expr, finalStage bool) *OrderedAggregate

	 type OrderedSynchronizer (struct)
		OrderedSynchronizer implements synchronizing ordered input from multiple
		goroutines. The strategy used is that any input that calls Callback must wait
		for all the other inputs to call Callback, since an ordered result cannot
		be produced until all inputs have pushed data. Another strategy would be to
		store the pushed records, but that requires fully copying all the data for
		safety.

		Methods (total 5)
			(*OrderedSynchronizer) Callback(ctx context.Context, r arrow.Record) error
			(*OrderedSynchronizer) Close()
			(*OrderedSynchronizer) Draw() *Diagram
			(*OrderedSynchronizer) Finish(ctx context.Context) error
			(*OrderedSynchronizer) SetNext(next PhysicalPlan)
		Implements (at least one exported)
			*OrderedSynchronizer : PhysicalPlan
		As Outputs Of (at least one exported)
			func NewOrderedSynchronizer(pool memory.Allocator, inputs int, orderByExprs []logicalplan.Expr) *OrderedSynchronizer

	 type OrExpr (struct)

		Fields (total 2)
			Left BooleanExpression
			Right BooleanExpression
		Methods (total 2)
			(*OrExpr) Eval(r arrow.Record) (*Bitmap, error)
			(*OrExpr) String() string
		Implements (at least 3)
			*OrExpr : BooleanExpression
			*OrExpr : expvar.Var
			*OrExpr : fmt.Stringer

	 type OutputPlan (struct)

		Methods (total 8)
			(*OutputPlan) Callback(ctx context.Context, r arrow.Record) error
			(*OutputPlan) Close()
			(*OutputPlan) Draw() *Diagram
			(*OutputPlan) DrawString() string
			(*OutputPlan) Execute(ctx context.Context, pool memory.Allocator, callback func(ctx context.Context, r arrow.Record) error) error
			(*OutputPlan) Finish(_ context.Context) error
			(*OutputPlan) SetNext(_ PhysicalPlan)
			(*OutputPlan) SetNextCallback(next func(ctx context.Context, r arrow.Record) error)
		Implements (at least one exported)
			*OutputPlan : PhysicalPlan
		As Outputs Of (at least one exported)
			func Build(ctx context.Context, pool memory.Allocator, tracer trace.Tracer, s *dynparquet.Schema, plan *logicalplan.LogicalPlan, options ...Option) (*OutputPlan, error)

	 type PhysicalPlan (interface)

		Methods (total 5)
			( PhysicalPlan) Callback(ctx context.Context, r arrow.Record) error
			( PhysicalPlan) Close()
			( PhysicalPlan) Draw() *Diagram
			( PhysicalPlan) Finish(ctx context.Context) error
			( PhysicalPlan) SetNext(next PhysicalPlan)
		Implemented By (at least 10)
			*Distinction
			*HashAggregate
			*Limiter
			*OrderedAggregate
			*OrderedSynchronizer
			*OutputPlan
			*PredicateFilter
			*Projection
			*ReservoirSampler
			*Synchronizer
		As Outputs Of (at least one exported)
			func Aggregate(pool memory.Allocator, tracer trace.Tracer, agg *logicalplan.Aggregation, final bool, ordered bool, seed maphash.Seed) (PhysicalPlan, error)
		As Inputs Of (at least 13)
			func WithOverrideInput(input []PhysicalPlan) Option
			func (*Distinction).SetNext(plan PhysicalPlan)
			func (*HashAggregate).SetNext(next PhysicalPlan)
			func (*Limiter).SetNext(next PhysicalPlan)
			func (*OrderedAggregate).SetNext(next PhysicalPlan)
			func (*OrderedSynchronizer).SetNext(next PhysicalPlan)
			func (*OutputPlan).SetNext(_ PhysicalPlan)
			func PhysicalPlan.SetNext(next PhysicalPlan)
			func (*PredicateFilter).SetNext(next PhysicalPlan)
			func (*Projection).SetNext(next PhysicalPlan)
			func (*ReservoirSampler).SetNext(p PhysicalPlan)
			func (*Synchronizer).SetNext(next PhysicalPlan)
			func (*Synchronizer).SetNextPlan(nextPlan PhysicalPlan)

	 type PostPlanVisitorFunc (func)

		Methods (total 2)
			( PostPlanVisitorFunc) PostVisit(plan *logicalplan.LogicalPlan) bool
			( PostPlanVisitorFunc) PreVisit(_ *logicalplan.LogicalPlan) bool
		Implements (at least one exported)
			 PostPlanVisitorFunc : github.com/polarsignals/frostdb/query/logicalplan.PlanVisitor

	 type PredicateFilter (struct)

		Methods (total 5)
			(*PredicateFilter) Callback(ctx context.Context, r arrow.Record) error
			(*PredicateFilter) Close()
			(*PredicateFilter) Draw() *Diagram
			(*PredicateFilter) Finish(ctx context.Context) error
			(*PredicateFilter) SetNext(next PhysicalPlan)
		Implements (at least one exported)
			*PredicateFilter : PhysicalPlan
		As Outputs Of (at least one exported)
			func Filter(pool memory.Allocator, tracer trace.Tracer, filterExpr logicalplan.Expr) (*PredicateFilter, error)

	 type PreExprVisitorFunc (func)

		Methods (total 3)
			( PreExprVisitorFunc) PostVisit(_ logicalplan.Expr) bool
			( PreExprVisitorFunc) PreVisit(expr logicalplan.Expr) bool
			( PreExprVisitorFunc) Visit(_ logicalplan.Expr) bool
		Implements (at least one exported)
			 PreExprVisitorFunc : github.com/polarsignals/frostdb/query/logicalplan.Visitor

	 type PrePlanVisitorFunc (func)

		Methods (total 2)
			( PrePlanVisitorFunc) PostVisit(_ *logicalplan.LogicalPlan) bool
			( PrePlanVisitorFunc) PreVisit(plan *logicalplan.LogicalPlan) bool
		Implements (at least one exported)
			 PrePlanVisitorFunc : github.com/polarsignals/frostdb/query/logicalplan.PlanVisitor

	 type Projection (struct)

		Methods (total 6)
			(*Projection) Callback(ctx context.Context, r arrow.Record) error
			(*Projection) Close()
			(*Projection) Draw() *Diagram
			(*Projection) Finish(ctx context.Context) error
			(*Projection) Project(_ context.Context, r arrow.Record) (arrow.Record, error)
			(*Projection) SetNext(next PhysicalPlan)
		Implements (at least one exported)
			*Projection : PhysicalPlan
		As Outputs Of (at least one exported)
			func Project(mem memory.Allocator, tracer trace.Tracer, exprs []logicalplan.Expr) (*Projection, error)

	 type RegExpFilter (struct)

		Methods (total 2)
			(*RegExpFilter) Eval(r arrow.Record) (*Bitmap, error)
			(*RegExpFilter) String() string
		Implements (at least 3)
			*RegExpFilter : BooleanExpression
			*RegExpFilter : expvar.Var
			*RegExpFilter : fmt.Stringer

	 type ReservoirSampler (struct)

		Methods (total 5)
			(*ReservoirSampler) Callback(_ context.Context, r arrow.Record) error
				Callback collects all the records to sample.

			(*ReservoirSampler) Close()
			(*ReservoirSampler) Draw() *Diagram
			(*ReservoirSampler) Finish(ctx context.Context) error
				Finish sends all the records in the reservoir to the next operator.

			(*ReservoirSampler) SetNext(p PhysicalPlan)
		Implements (at least one exported)
			*ReservoirSampler : PhysicalPlan
		As Outputs Of (at least one exported)
			func NewReservoirSampler(size, limit int64, allocator memory.Allocator) *ReservoirSampler

	 type ScanPhysicalPlan (interface)

		Methods (total 2)
			( ScanPhysicalPlan) Draw() *Diagram
			( ScanPhysicalPlan) Execute(ctx context.Context, pool memory.Allocator) error
		Implemented By (at least 2)
			*SchemaScan
			*TableScan

	 type SchemaScan (struct)

		Methods (total 2)
			(*SchemaScan) Draw() *Diagram
			(*SchemaScan) Execute(ctx context.Context, pool memory.Allocator) error
		Implements (at least one exported)
			*SchemaScan : ScanPhysicalPlan

	 type SumAggregation (struct)

		Methods (only one)
			(*SumAggregation) Aggregate(pool memory.Allocator, arrs []arrow.Array) (arrow.Array, error)
		Implements (at least one exported)
			*SumAggregation : AggregationFunction

	 type Synchronizer (struct)
		Synchronizer is used to combine the results of multiple parallel streams
		into a single stream concurrent stream. It also forms a barrier on the
		finishers, by waiting to call next plan's finish until all previous parallel
		stages have finished.

		Methods (total 6)
			(*Synchronizer) Callback(ctx context.Context, r arrow.Record) error
			(*Synchronizer) Close()
			(*Synchronizer) Draw() *Diagram
			(*Synchronizer) Finish(ctx context.Context) error
			(*Synchronizer) SetNext(next PhysicalPlan)
			(*Synchronizer) SetNextPlan(nextPlan PhysicalPlan)
		Implements (at least one exported)
			*Synchronizer : PhysicalPlan
		As Outputs Of (at least one exported)
			func Synchronize(concurrency int) *Synchronizer

	 type TableScan (struct)

		Methods (total 2)
			(*TableScan) Draw() *Diagram
			(*TableScan) Execute(ctx context.Context, pool memory.Allocator) error
		Implements (at least one exported)
			*TableScan : ScanPhysicalPlan

	 type UniqueAggregation (struct)

		Methods (only one)
			(*UniqueAggregation) Aggregate(pool memory.Allocator, arrs []arrow.Array) (arrow.Array, error)
		Implements (at least one exported)
			*UniqueAggregation : AggregationFunction


Package-Level Functions (total 46)

	 func AddFloat64s(mem memory.Allocator, left, right *array.Float64) *array.Float64
	 func AddInt32s(mem memory.Allocator, left, right *array.Int32) *array.Int32
	 func AddInt64s(mem memory.Allocator, left, right *array.Int64) *array.Int64
	 func AddUint64s(mem memory.Allocator, left, right *array.Uint64) *array.Uint64
	 func Aggregate(pool memory.Allocator, tracer trace.Tracer, agg *logicalplan.Aggregation, final bool, ordered bool, seed maphash.Seed) (PhysicalPlan, error)
	 func AndArrays(pool memory.Allocator, arrs []arrow.Array) arrow.Array
	 func ArrayScalarCompute(funcName string, left arrow.Array, right scalar.Scalar) (*Bitmap, error)
	 func ArrayScalarContains(arr arrow.Array, right scalar.Scalar, not bool) (*Bitmap, error)
	 func ArrayScalarRegexMatch(left arrow.Array, right *regexp.Regexp) (*Bitmap, error)
	 func ArrayScalarRegexNotMatch(left arrow.Array, right *regexp.Regexp) (*Bitmap, error)
	 func BinaryArrayScalarRegexMatch(left *array.Binary, right *regexp.Regexp) (*Bitmap, error)
	 func BinaryArrayScalarRegexNotMatch(left *array.Binary, right *regexp.Regexp) (*Bitmap, error)
	 func BinaryDictionaryArrayScalarRegexMatch(dict *array.Dictionary, left *array.Binary, right *regexp.Regexp) (*Bitmap, error)
	 func BinaryDictionaryArrayScalarRegexNotMatch(dict *array.Dictionary, left *array.Binary, right *regexp.Regexp) (*Bitmap, error)
	 func BinaryScalarOperation(left arrow.Array, right scalar.Scalar, operator logicalplan.Op) (*Bitmap, error)
	 func Build(ctx context.Context, pool memory.Allocator, tracer trace.Tracer, s *dynparquet.Schema, plan *logicalplan.LogicalPlan, options ...Option) (*OutputPlan, error)
	 func DictionaryArrayScalarContains(left *array.Dictionary, right scalar.Scalar, not bool) (*Bitmap, error)
	 func DictionaryArrayScalarEqual(left *array.Dictionary, right scalar.Scalar) (*Bitmap, error)
	 func DictionaryArrayScalarNotEqual(left *array.Dictionary, right scalar.Scalar) (*Bitmap, error)
	 func Distinct(pool memory.Allocator, tracer trace.Tracer, columns []logicalplan.Expr) *Distinction
	 func DivFloat64s(mem memory.Allocator, left, right *array.Float64) *array.Float64
	 func DivInt32s(mem memory.Allocator, left, right *array.Int32) *array.Int32
	 func DivInt64s(mem memory.Allocator, left, right *array.Int64) *array.Int64
	 func DivUint64s(mem memory.Allocator, left, right *array.Uint64) *array.Uint64
	 func Filter(pool memory.Allocator, tracer trace.Tracer, filterExpr logicalplan.Expr) (*PredicateFilter, error)
	 func Limit(pool memory.Allocator, tracer trace.Tracer, expr logicalplan.Expr) (*Limiter, error)
	 func MulFloat64s(mem memory.Allocator, left, right *array.Float64) *array.Float64
	 func MulInt32s(mem memory.Allocator, left, right *array.Int32) *array.Int32
	 func MulInt64s(mem memory.Allocator, left, right *array.Int64) *array.Int64
	 func MulUint64s(mem memory.Allocator, left, right *array.Uint64) *array.Uint64
	 func NewBitmap() *Bitmap
	 func NewHashAggregate(pool memory.Allocator, tracer trace.Tracer, aggregations []Aggregation, groupByColumnMatchers []logicalplan.Expr, seed maphash.Seed, finalStage bool) *HashAggregate
	 func NewOrderedAggregate(pool memory.Allocator, tracer trace.Tracer, aggregation Aggregation, groupByColumnMatchers []logicalplan.Expr, finalStage bool) *OrderedAggregate
	 func NewOrderedSynchronizer(pool memory.Allocator, inputs int, orderByExprs []logicalplan.Expr) *OrderedSynchronizer
	 func NewReservoirSampler(size, limit int64, allocator memory.Allocator) *ReservoirSampler
		NewReservoirSampler will create a new ReservoirSampler operator that will sample up to size rows of all records seen by Callback.

	 func Project(mem memory.Allocator, tracer trace.Tracer, exprs []logicalplan.Expr) (*Projection, error)
	 func StringArrayScalarRegexMatch(left *array.String, right *regexp.Regexp) (*Bitmap, error)
	 func StringArrayScalarRegexNotMatch(left *array.String, right *regexp.Regexp) (*Bitmap, error)
	 func SubFloat64s(mem memory.Allocator, left, right *array.Float64) *array.Float64
	 func SubInt32s(mem memory.Allocator, left, right *array.Int32) *array.Int32
	 func SubInt64s(mem memory.Allocator, left, right *array.Int64) *array.Int64
	 func SubUint64s(mem memory.Allocator, left, right *array.Uint64) *array.Uint64
	 func Synchronize(concurrency int) *Synchronizer
	 func WithOrderedAggregations() Option
	 func WithOverrideInput(input []PhysicalPlan) Option
		WithOverrideInput can be used to provide an input stage on top of which the
		Build function can build the physical plan.

	 func WithReadMode(m logicalplan.ReadMode) Option
Package-Level Variables (total 7)

	  var ErrUnsupportedAndType error
	  var ErrUnsupportedBinaryOperation error
	  var ErrUnsupportedBooleanExpression error
	  var ErrUnsupportedIsUniqueType error
	  var ErrUnsupportedMaxType error
	  var ErrUnsupportedMinType error
	  var ErrUnsupportedSumType error

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.