*: fix unused linter errors

polarsignals · Nov 29, 2023 · e357841 · e357841
1 parent e3936f6
commit e357841
Show file tree

Hide file tree

Showing 22 changed files with 78 additions and 69 deletions.
diff --git a/dynparquet/nil_chunk.go b/dynparquet/nil_chunk.go
@@ -217,7 +217,7 @@ func (p *nilPage) Data() encoding.Values {
 	panic("not implemented")
 }
 
-func (p *nilPage) Slice(i, j int64) parquet.Page {
+func (p *nilPage) Slice(_, _ int64) parquet.Page {
 	return &nilPage{
 		numValues:   p.numValues,
 		columnIndex: p.columnIndex,

diff --git a/dynparquet/schema.go b/dynparquet/schema.go
@@ -469,7 +469,7 @@ func (s *v2storageLayoutWrapper) GetCompressionInt32() int32 {
 	return int32(s.StorageLayout.GetCompression())
 }
 
-func StorageLayoutWrapper(layout *schemav2pb.StorageLayout) StorageLayout {
+func StorageLayoutWrapper(_ *schemav2pb.StorageLayout) StorageLayout {
 	return nil
 }
 
@@ -1290,13 +1290,13 @@ func (s *Schema) GetWriter(w io.Writer, dynamicColumns map[string][]string, sort
 	pool, _ := s.writers.LoadOrStore(fmt.Sprintf("%s,sorting=%t", key, sorting), &sync.Pool{})
 	pooled := pool.(*sync.Pool).Get()
 	if pooled == nil {
-		new, err := s.NewWriter(w, dynamicColumns, sorting)
+		pw, err := s.NewWriter(w, dynamicColumns, sorting)
 		if err != nil {
 			return nil, err
 		}
 		return &PooledWriter{
 			pool:          pool.(*sync.Pool),
-			ParquetWriter: new,
+			ParquetWriter: pw,
 		}, nil
 	}
 	pooled.(*PooledWriter).ParquetWriter.Reset(w)
@@ -1372,13 +1372,13 @@ func (s *Schema) GetBuffer(dynamicColumns map[string][]string) (*PooledBuffer, e
 	pool, _ := s.buffers.LoadOrStore(key, &sync.Pool{})
 	pooled := pool.(*sync.Pool).Get()
 	if pooled == nil {
-		new, err := s.NewBuffer(dynamicColumns)
+		pw, err := s.NewBuffer(dynamicColumns)
 		if err != nil {
 			return nil, err
 		}
 		return &PooledBuffer{
 			pool:   pool.(*sync.Pool),
-			Buffer: new,
+			Buffer: pw,
 		}, nil
 	}
 	return pooled.(*PooledBuffer), nil

diff --git a/index/lsm.go b/index/lsm.go
@@ -203,7 +203,7 @@ func (l *LSM) String() string {
 	return s
 }
 
-func (l *LSM) Prefixes(ctx context.Context, prefix string) ([]string, error) {
+func (l *LSM) Prefixes(_ context.Context, _ string) ([]string, error) {
 	return []string{l.prefix}, nil
 }
 
@@ -298,12 +298,16 @@ func (l *LSM) findNode(node *Node) *Node {
 // levels are below the target size.
 func (l *LSM) EnsureCompaction() error {
 	for !l.compacting.CompareAndSwap(false, true) { // TODO: should backoff retry this probably
+		// Satisfy linter with a statement.
+		continue
 	}
 	return l.compact(true /* ignoreSizes */)
 }
 
 func (l *LSM) Rotate(level SentinelType, externalWriter func([]*parts.Part) (*parts.Part, int64, int64, error)) error {
 	for !l.compacting.CompareAndSwap(false, true) { // TODO: should backoff retry this probably
+		// Satisfy linter with a statement.
+		continue
 	}
 	defer l.compacting.Store(false)
 	start := time.Now()

diff --git a/index/lsm_test.go b/index/lsm_test.go
@@ -16,7 +16,7 @@ import (
 	"github.com/polarsignals/frostdb/parts"
 )
 
-func parquetCompaction(compact []*parts.Part, options ...parts.Option) ([]*parts.Part, int64, int64, error) {
+func parquetCompaction(compact []*parts.Part, _ ...parts.Option) ([]*parts.Part, int64, int64, error) {
 	b := &bytes.Buffer{}
 	size, err := compactParts(b, compact)
 	if err != nil {

diff --git a/logictest/runner.go b/logictest/runner.go
@@ -105,7 +105,7 @@ func (r *Runner) handleCmd(ctx context.Context, c *datadriven.TestData) (string,
 	return "", fmt.Errorf("unknown command %s", c.Cmd)
 }
 
-func (r *Runner) handleCreateTable(ctx context.Context, c *datadriven.TestData) (string, error) {
+func (r *Runner) handleCreateTable(_ context.Context, c *datadriven.TestData) (string, error) {
 	var schema *schemapb.Schema
 	for _, arg := range c.CmdArgs {
 		if arg.Key == "schema" {

diff --git a/pqarrow/arrow.go b/pqarrow/arrow.go
@@ -270,7 +270,7 @@ func (c *ParquetConverter) Convert(ctx context.Context, rg parquet.RowGroup) err
 	}
 
 	if _, ok := rg.(*dynparquet.MergedRowGroup); ok {
-		return rowBasedParquetRowGroupToArrowRecord(ctx, c.pool, rg, c.outputSchema, c.builder)
+		return rowBasedParquetRowGroupToArrowRecord(ctx, rg, c.outputSchema, c.builder)
 	}
 
 	parquetSchema := rg.Schema()
@@ -608,7 +608,6 @@ var rowBufPool = &sync.Pool{
 // record row by row. The result is appended to b.
 func rowBasedParquetRowGroupToArrowRecord(
 	ctx context.Context,
-	pool memory.Allocator,
 	rg parquet.RowGroup,
 	schema *arrow.Schema,
 	builder *builder.RecordBuilder,
@@ -852,11 +851,11 @@ func (f PreExprVisitorFunc) PreVisit(expr logicalplan.Expr) bool {
 	return f(expr)
 }
 
-func (f PreExprVisitorFunc) Visit(expr logicalplan.Expr) bool {
+func (f PreExprVisitorFunc) Visit(_ logicalplan.Expr) bool {
 	return false
 }
 
-func (f PreExprVisitorFunc) PostVisit(expr logicalplan.Expr) bool {
+func (f PreExprVisitorFunc) PostVisit(_ logicalplan.Expr) bool {
 	return false
 }
 

diff --git a/pqarrow/arrowutils/merge.go b/pqarrow/arrowutils/merge.go
@@ -120,7 +120,7 @@ func (h cursorHeap) Swap(i, j int) {
 	h.cursors[i], h.cursors[j] = h.cursors[j], h.cursors[i]
 }
 
-func (h cursorHeap) Push(x any) {
+func (h cursorHeap) Push(_ any) {
 	panic(
 		"number of cursors are known at Init time, none should ever be pushed",
 	)

diff --git a/pqarrow/arrowutils/nullarray.go b/pqarrow/arrowutils/nullarray.go
@@ -76,6 +76,6 @@ func (n VirtualNullArray) Release() {}
 
 func (n VirtualNullArray) String() string { return "VirtualNullArray" }
 
-func (n VirtualNullArray) ValueStr(i int) string { return "" }
+func (n VirtualNullArray) ValueStr(_ int) string { return "" }
 
 func (n VirtualNullArray) GetOneForMarshal(_ int) any { return nil }
diff --git a/pqarrow/builder/optbuilders.go b/pqarrow/builder/optbuilders.go
@@ -525,7 +525,7 @@ func (b *OptBooleanBuilder) Value(i int) bool {
 	return bitutil.BitIsSet(b.data, i)
 }
 
-func (b *OptBooleanBuilder) AppendData(data []byte) {
+func (b *OptBooleanBuilder) AppendData(_ []byte) {
 	panic("do not use AppendData for opt boolean builder, use Append instead")
 }
 

diff --git a/pqarrow/writer/writer.go b/pqarrow/writer/writer.go
@@ -24,7 +24,7 @@ type binaryValueWriter struct {
 
 type NewWriterFunc func(b builder.ColumnBuilder, numValues int) ValueWriter
 
-func NewBinaryValueWriter(b builder.ColumnBuilder, numValues int) ValueWriter {
+func NewBinaryValueWriter(b builder.ColumnBuilder, _ int) ValueWriter {
 	return &binaryValueWriter{
 		b: b.(*builder.OptBinaryBuilder),
 	}
@@ -455,11 +455,11 @@ func NewMapWriter(b builder.ColumnBuilder, _ int) ValueWriter {
 	}
 }
 
-func (m *mapWriter) WritePage(p parquet.Page) error {
+func (m *mapWriter) WritePage(_ parquet.Page) error {
 	panic("not implemented")
 }
 
-func (m *mapWriter) Write(values []parquet.Value) {
+func (m *mapWriter) Write(_ []parquet.Value) {
 	panic("not implemented")
 }
 

diff --git a/query/expr/filter.go b/query/expr/filter.go
@@ -16,11 +16,11 @@ func (f PreExprVisitorFunc) PreVisit(expr logicalplan.Expr) bool {
 	return f(expr)
 }
 
-func (f PreExprVisitorFunc) Visit(expr logicalplan.Expr) bool {
+func (f PreExprVisitorFunc) Visit(_ logicalplan.Expr) bool {
 	return false
 }
 
-func (f PreExprVisitorFunc) PostVisit(expr logicalplan.Expr) bool {
+func (f PreExprVisitorFunc) PostVisit(_ logicalplan.Expr) bool {
 	return false
 }
 
@@ -38,7 +38,7 @@ type TrueNegativeFilter interface {
 
 type AlwaysTrueFilter struct{}
 
-func (f *AlwaysTrueFilter) Eval(p Particulate) (bool, error) {
+func (f *AlwaysTrueFilter) Eval(_ Particulate) (bool, error) {
 	return true, nil
 }
 

diff --git a/query/logicalplan/expr.go b/query/logicalplan/expr.go
@@ -611,11 +611,11 @@ func (d *DurationExpr) Clone() Expr {
 	}
 }
 
-func (d *DurationExpr) DataType(schema *parquet.Schema) (arrow.DataType, error) {
+func (d *DurationExpr) DataType(_ *parquet.Schema) (arrow.DataType, error) {
 	return &arrow.DurationType{}, nil
 }
 
-func (d *DurationExpr) MatchPath(path string) bool {
+func (d *DurationExpr) MatchPath(_ string) bool {
 	return false
 }
 
@@ -716,7 +716,7 @@ func (a *RegexpColumnMatch) Clone() Expr {
 	}
 }
 
-func (a *RegexpColumnMatch) DataType(s *parquet.Schema) (arrow.DataType, error) {
+func (a *RegexpColumnMatch) DataType(_ *parquet.Schema) (arrow.DataType, error) {
 	return nil, nil
 }
 
@@ -768,10 +768,10 @@ func (a *AllExpr) Name() string { return "all" }
 func (a *AllExpr) ColumnsUsedExprs() []Expr {
 	return []Expr{&AllExpr{}}
 }
-func (a *AllExpr) MatchColumn(columnName string) bool { return true }
-func (a *AllExpr) MatchPath(path string) bool         { return true }
-func (a *AllExpr) Computed() bool                     { return false }
-func (a *AllExpr) Clone() Expr                        { return &AllExpr{} }
+func (a *AllExpr) MatchColumn(_ string) bool { return true }
+func (a *AllExpr) MatchPath(_ string) bool   { return true }
+func (a *AllExpr) Computed() bool            { return false }
+func (a *AllExpr) Clone() Expr               { return &AllExpr{} }
 
 type NotExpr struct {
 	Expr Expr

diff --git a/query/logicalplan/logicalplan_test.go b/query/logicalplan/logicalplan_test.go
@@ -18,26 +18,26 @@ func (m *mockTableReader) Schema() *dynparquet.Schema {
 	return m.schema
 }
 
-func (m *mockTableReader) View(ctx context.Context, fn func(ctx context.Context, tx uint64) error) error {
+func (m *mockTableReader) View(_ context.Context, _ func(ctx context.Context, tx uint64) error) error {
 	return nil
 }
 
 func (m *mockTableReader) Iterator(
-	ctx context.Context,
-	tx uint64,
-	pool memory.Allocator,
-	callbacks []Callback,
-	iterOpts ...Option,
+	_ context.Context,
+	_ uint64,
+	_ memory.Allocator,
+	_ []Callback,
+	_ ...Option,
 ) error {
 	return nil
 }
 
 func (m *mockTableReader) SchemaIterator(
-	ctx context.Context,
-	tx uint64,
-	pool memory.Allocator,
-	callbacks []Callback,
-	iterOpts ...Option,
+	_ context.Context,
+	_ uint64,
+	_ memory.Allocator,
+	_ []Callback,
+	_ ...Option,
 ) error {
 	return nil
 }
@@ -46,7 +46,7 @@ type mockTableProvider struct {
 	schema *dynparquet.Schema
 }
 
-func (m *mockTableProvider) GetTable(name string) (TableReader, error) {
+func (m *mockTableProvider) GetTable(_ string) (TableReader, error) {
 	return &mockTableReader{
 		schema: m.schema,
 	}, nil

diff --git a/query/logicalplan/validate.go b/query/logicalplan/validate.go
@@ -409,11 +409,11 @@ type findExpressionForTypeVisitor struct {
 	result Expr
 }
 
-func (v *findExpressionForTypeVisitor) PreVisit(expr Expr) bool {
+func (v *findExpressionForTypeVisitor) PreVisit(_ Expr) bool {
 	return true
 }
 
-func (v *findExpressionForTypeVisitor) Visit(expr Expr) bool {
+func (v *findExpressionForTypeVisitor) Visit(_ Expr) bool {
 	return true
 }
 

diff --git a/query/physicalplan/aggregate.go b/query/physicalplan/aggregate.go
@@ -305,7 +305,7 @@ func (d *durationHashCombine) hashCombine(rhs uint64) uint64 {
 	return rhs / d.milliseconds // floors by default
 }
 
-func (a *HashAggregate) Callback(ctx context.Context, r arrow.Record) error {
+func (a *HashAggregate) Callback(_ context.Context, r arrow.Record) error {
 	// Generates high volume of spans. Comment out if needed during development.
 	// ctx, span := a.tracer.Start(ctx, "HashAggregate/Callback")
 	// defer span.End()

diff --git a/query/physicalplan/filter.go b/query/physicalplan/filter.go
@@ -53,11 +53,11 @@ func (f PreExprVisitorFunc) PreVisit(expr logicalplan.Expr) bool {
 	return f(expr)
 }
 
-func (f PreExprVisitorFunc) Visit(expr logicalplan.Expr) bool {
+func (f PreExprVisitorFunc) Visit(_ logicalplan.Expr) bool {
 	return false
 }
 
-func (f PreExprVisitorFunc) PostVisit(expr logicalplan.Expr) bool {
+func (f PreExprVisitorFunc) PostVisit(_ logicalplan.Expr) bool {
 	return false
 }
 

diff --git a/query/physicalplan/physicalplan_test.go b/query/physicalplan/physicalplan_test.go
@@ -21,26 +21,26 @@ func (m *mockTableReader) Schema() *dynparquet.Schema {
 	return m.schema
 }
 
-func (m *mockTableReader) View(ctx context.Context, fn func(ctx context.Context, tx uint64) error) error {
+func (m *mockTableReader) View(_ context.Context, _ func(ctx context.Context, tx uint64) error) error {
 	return nil
 }
 
 func (m *mockTableReader) Iterator(
-	ctx context.Context,
-	tx uint64,
-	pool memory.Allocator,
-	callbacks []logicalplan.Callback,
-	iterOpts ...logicalplan.Option,
+	_ context.Context,
+	_ uint64,
+	_ memory.Allocator,
+	_ []logicalplan.Callback,
+	_ ...logicalplan.Option,
 ) error {
 	return nil
 }
 
 func (m *mockTableReader) SchemaIterator(
-	ctx context.Context,
-	tx uint64,
-	pool memory.Allocator,
-	callbacks []logicalplan.Callback,
-	iterOpts ...logicalplan.Option,
+	_ context.Context,
+	_ uint64,
+	_ memory.Allocator,
+	_ []logicalplan.Callback,
+	_ ...logicalplan.Option,
 ) error {
 	return nil
 }
@@ -49,7 +49,7 @@ type mockTableProvider struct {
 	schema *dynparquet.Schema
 }
 
-func (m *mockTableProvider) GetTable(name string) (logicalplan.TableReader, error) {
+func (m *mockTableProvider) GetTable(_ string) (logicalplan.TableReader, error) {
 	return &mockTableReader{
 		schema: m.schema,
 	}, nil

diff --git a/query/physicalplan/project.go b/query/physicalplan/project.go
@@ -134,7 +134,7 @@ func (p plainProjection) Name() string {
 	return p.expr.ColumnName
 }
 
-func (p plainProjection) Project(mem memory.Allocator, ar arrow.Record) ([]arrow.Field, []arrow.Array, error) {
+func (p plainProjection) Project(_ memory.Allocator, ar arrow.Record) ([]arrow.Field, []arrow.Array, error) {
 	for i := 0; i < ar.Schema().NumFields(); i++ {
 		field := ar.Schema().Field(i)
 		if p.expr.MatchColumn(field.Name) {
@@ -154,7 +154,7 @@ func (p dynamicProjection) Name() string {
 	return p.expr.ColumnName
 }
 
-func (p dynamicProjection) Project(mem memory.Allocator, ar arrow.Record) ([]arrow.Field, []arrow.Array, error) {
+func (p dynamicProjection) Project(_ memory.Allocator, ar arrow.Record) ([]arrow.Field, []arrow.Array, error) {
 	fields := []arrow.Field{}
 	arrays := []arrow.Array{}
 	for i := 0; i < ar.Schema().NumFields(); i++ {
@@ -367,6 +367,6 @@ type allProjection struct{}
 
 func (a allProjection) Name() string { return "all" }
 
-func (a allProjection) Project(mem memory.Allocator, ar arrow.Record) ([]arrow.Field, []arrow.Array, error) {
+func (a allProjection) Project(_ memory.Allocator, ar arrow.Record) ([]arrow.Field, []arrow.Array, error) {
 	return ar.Schema().Fields(), ar.Columns(), nil
 }