remove ast.DefaultScan, dag.DefaultScan, and sem.DefaultScan

compiler/ast/op.go

@@ -239,9 +239,6 @@ type (
 		Meta *Text  `json:"meta"`
 		Loc  `json:"loc"`
 	}
-	DefaultScan struct {
-		Kind string `json:"kind" unpack:""`
-	}
 	Delete struct {
 		Kind   string       `json:"kind" unpack:""`
 		Pool   string       `json:"pool"`
@@ -284,9 +281,6 @@ type FromItem struct {
 	Loc    `json:"loc"`
 }
 
-func (d *DefaultScan) Pos() int { return -1 }
-func (d *DefaultScan) End() int { return -1 }
-
 type ArgExpr struct {
 	Kind  string `json:"kind" unpack:""`
 	Key   string `json:"key"`
@@ -374,5 +368,3 @@ func (*UniqOp) opNode()       {}
 func (*UnnestOp) opNode()     {}
 func (*ValuesOp) opNode()     {}
 func (*WhereOp) opNode()      {}
-
-func (*DefaultScan) opNode() {}

compiler/ast/unpack.go

@@ -29,7 +29,6 @@ var unpacker = unpack.New(
 	DebugOp{},
 	DeclsValue{},
 	Decorated{},
-	DefaultScan{},
 	Delete{},
 	DoubleQuoteExpr{},
 	DropOp{},

compiler/dag/op.go

@@ -12,7 +12,6 @@ import (
 	"reflect"
 	"slices"
 
-	"github.com/brimdata/super/order"
 	"github.com/brimdata/super/pkg/field"
 	"github.com/segmentio/ksuid"
 )
@@ -251,11 +250,6 @@ type (
 		Kind string `json:"kind" unpack:""`
 		Meta string `json:"meta"`
 	}
-	DefaultScan struct {
-		Kind     string         `json:"kind" unpack:""`
-		Filter   Expr           `json:"filter"`
-		SortKeys order.SortKeys `json:"sort_keys"`
-	}
 	DeleterScan struct {
 		Kind      string      `json:"kind" unpack:""`
 		Pool      ksuid.KSUID `json:"pool"`
@@ -349,7 +343,6 @@ var CommitMetas = map[string]struct{}{
 
 func (*CommitMetaScan) opNode() {}
 func (*DBMetaScan) opNode()     {}
-func (*DefaultScan) opNode()    {}
 func (*DeleterScan) opNode()    {}
 func (*DeleteScan) opNode()     {}
 func (*FileScan) opNode()       {}

compiler/dag/unpack.go

@@ -20,7 +20,6 @@ var unpacker = unpack.New(
 	CountOp{},
 	CutOp{},
 	DebugOp{},
-	DefaultScan{},
 	DeleterScan{},
 	DeleteScan{},
 	DistinctOp{},

compiler/describe/analyze.go

@@ -112,8 +112,6 @@ func describeSources(ctx context.Context, root *db.Root, o dag.Op) ([]Source, er
 			s = append(s, out...)
 		}
 		return s, nil
-	case *dag.DefaultScan:
-		return []Source{&Path{Kind: "Path", URI: "stdio://stdin"}}, nil
 	case *dag.NullScan:
 		return []Source{&Null{Kind: "Null"}}, nil
 	case *dag.FileScan:

compiler/optimizer/demand.go

@@ -114,7 +114,7 @@ func demandForSimpleOp(op dag.Op, downstream demand.Demand) demand.Demand {
 		}
 		return d
 
-	case *dag.CommitMetaScan, *dag.DefaultScan, *dag.DeleterScan, *dag.DeleteScan, *dag.DBMetaScan:
+	case *dag.CommitMetaScan, *dag.DeleterScan, *dag.DeleteScan, *dag.DBMetaScan:
 		return demand.None()
 	case *dag.FileScan:
 		if mf := op.Pushdown.MetaFilter; mf != nil {

compiler/optimizer/optimizer.go

@@ -281,10 +281,6 @@ func (o *Optimizer) optimizeSourcePaths(seq dag.Seq) (dag.Seq, error) {
 				}
 				seq = dag.Seq{op, o}
 			}
-		case *dag.DefaultScan:
-			o.nent++
-			op.Filter = filter
-			seq = append(dag.Seq{op}, chain...)
 		}
 		return seq, nil
 	})
@@ -363,7 +359,7 @@ func (o *Optimizer) propagateSortKeyOp(op dag.Op, parents []order.SortKeys) ([]o
 			sortKeys = nil
 		}
 		return []order.SortKeys{sortKeys}, nil
-	case *dag.PoolScan, *dag.ListerScan, *dag.SeqScan, *dag.DefaultScan:
+	case *dag.PoolScan, *dag.ListerScan, *dag.SeqScan:
 		out, err := o.sortKeysOfSource(op)
 		return []order.SortKeys{out}, err
 	default:
@@ -374,8 +370,6 @@ func (o *Optimizer) propagateSortKeyOp(op dag.Op, parents []order.SortKeys) ([]o
 
 func (o *Optimizer) sortKeysOfSource(op dag.Op) (order.SortKeys, error) {
 	switch op := op.(type) {
-	case *dag.DefaultScan:
-		return op.SortKeys, nil
 	case *dag.FileScan:
 		return nil, nil
 	case *dag.HTTPScan:
@@ -845,7 +839,7 @@ func setPushdownUnordered(seq dag.Seq, unordered bool) bool {
 	for i := len(seq) - 1; i >= 0; i-- {
 		switch op := seq[i].(type) {
 		case *dag.AggregateOp, *dag.CombineOp, *dag.DistinctOp, *dag.HashJoinOp, *dag.JoinOp, *dag.SortOp, *dag.TopOp,
-			*dag.DefaultScan, *dag.HTTPScan, *dag.PoolScan,
+			*dag.HTTPScan, *dag.PoolScan,
 			*dag.CommitMetaScan, *dag.DBMetaScan, *dag.PoolMetaScan:
 			unordered = true
 		case *dag.FileScan:

compiler/rungen/op.go

@@ -190,20 +190,6 @@ func (b *Builder) compileLeaf(o dag.Op, parent sbuf.Puller) (sbuf.Puller, error)
 		return meta.NewCommitMetaScanner(b.rctx.Context, b.sctx(), b.env.DB(), v.Pool, v.Commit, v.Meta, pruner)
 	case *dag.DBMetaScan:
 		return meta.NewDBMetaScanner(b.rctx.Context, b.sctx(), b.env.DB(), v.Meta)
-	case *dag.DefaultScan:
-		pushdown := b.newPushdown(v.Filter, nil)
-		if len(b.readers) == 1 {
-			return sbuf.NewScanner(b.rctx.Context, b.readers[0], pushdown)
-		}
-		scanners := make([]sbuf.Scanner, 0, len(b.readers))
-		for _, r := range b.readers {
-			scanner, err := sbuf.NewScanner(b.rctx.Context, r, pushdown)
-			if err != nil {
-				return nil, err
-			}
-			scanners = append(scanners, scanner)
-		}
-		return sbuf.MultiScanner(scanners...), nil
 	case *dag.DeleterScan:
 		pool, err := b.lookupPool(v.Pool)
 		if err != nil {
@@ -690,7 +676,7 @@ func isEntry(seq dag.Seq) bool {
 		return false
 	}
 	switch op := seq[0].(type) {
-	case *dag.ListerScan, *dag.DefaultScan, *dag.FileScan, *dag.HTTPScan, *dag.PoolScan, *dag.DBMetaScan, *dag.PoolMetaScan, *dag.CommitMetaScan, *dag.NullScan:
+	case *dag.ListerScan, *dag.FileScan, *dag.HTTPScan, *dag.PoolScan, *dag.DBMetaScan, *dag.PoolMetaScan, *dag.CommitMetaScan, *dag.NullScan:
 		return true
 	case *dag.ForkOp:
 		return len(op.Paths) > 0 && !slices.ContainsFunc(op.Paths, func(seq dag.Seq) bool {

compiler/rungen/vop.go

@@ -217,12 +217,6 @@ func (b *Builder) compileVamLeaf(o dag.Op, parent vio.Puller) (vio.Puller, error
 		}
 		d := vamop.NewDebug(b.rctx, e, filter, b.debugs, parent)
 		return d, nil
-	case *dag.DefaultScan:
-		sbufPuller, err := b.compileLeaf(o, nil)
-		if err != nil {
-			return nil, err
-		}
-		return sbuf.NewDematerializer(b.sctx(), sbufPuller), nil
 	case *dag.DistinctOp:
 		e, err := b.compileVamExpr(o.Expr)
 		if err != nil {

compiler/semantic/analyzer.go

@@ -96,7 +96,7 @@ func HasSource(seq sem.Seq) bool {
 		return false
 	}
 	switch op := seq[0].(type) {
-	case *sem.FileScan, *sem.HTTPScan, *sem.PoolScan, *sem.DBMetaScan, *sem.PoolMetaScan, *sem.CommitMetaScan, *sem.DeleteScan, *sem.NullScan, *sem.DefaultScan:
+	case *sem.FileScan, *sem.HTTPScan, *sem.PoolScan, *sem.DBMetaScan, *sem.PoolMetaScan, *sem.CommitMetaScan, *sem.DeleteScan, *sem.NullScan:
 		return true
 	case *sem.ForkOp:
 		for _, path := range op.Paths {

compiler/semantic/checker.go

@@ -56,8 +56,6 @@ func (c *checker) op(typ super.Type, op sem.Op) super.Type {
 	//
 	// Scanners first
 	//
-	case *sem.DefaultScan:
-		return c.unknown
 	case *sem.FileScan:
 		if op.Type == nil {
 			return c.unknown

compiler/semantic/compare.go

@@ -37,9 +37,6 @@ func eqOp(aop, bop sem.Op) bool {
 	case *sem.DBMetaScan:
 		b, ok := bop.(*sem.DBMetaScan)
 		return ok && a.Meta == b.Meta
-	case *sem.DefaultScan:
-		_, ok := bop.(*sem.DefaultScan)
-		return ok
 	case *sem.FileScan:
 		b, ok := bop.(*sem.FileScan)
 		return ok && slices.Equal(a.Paths, b.Paths) && a.Format == b.Format

compiler/semantic/dagen.go

@@ -73,10 +73,6 @@ func (d *dagen) op(op sem.Op) dag.Op {
 			Kind: "DBMetaScan",
 			Meta: op.Meta,
 		}
-	case *sem.DefaultScan:
-		return &dag.DefaultScan{
-			Kind: "DefaultScan",
-		}
 	case *sem.DeleteScan:
 		return &dag.DeleteScan{
 			Kind:   "DeleteScan",

compiler/semantic/evaluator.go

@@ -84,8 +84,6 @@ func (e *evaluator) op(op sem.Op) bool {
 	//
 	// Scanners first
 	//
-	case *sem.DefaultScan:
-		return false
 	case *sem.FileScan,
 		*sem.HTTPScan,
 		*sem.PoolScan,

compiler/semantic/fmt.go

@@ -22,8 +22,6 @@ func clrOp(op sem.Op) {
 	//
 	// Scanners first
 	//
-	case *sem.DefaultScan:
-		op.Node = nil
 	case *sem.FileScan:
 		op.Node = nil
 	case *sem.HTTPScan:

compiler/semantic/op.go

@@ -628,8 +628,6 @@ func (t *translator) semOp(o ast.Op, seq sem.Seq, inType super.Type) (sem.Seq, s
 	case *ast.FromOp:
 		seq, typ, _ := t.fromSource(o.Item.Source, o.Item.Args, seq)
 		return seq, typ
-	case *ast.DefaultScan:
-		return append(seq, &sem.DefaultScan{Node: o}), t.checker.unknown
 	case *ast.Delete:
 		if len(seq) > 0 {
 			panic("analyzer.SemOp: delete scan cannot have parent in AST")

compiler/semantic/sem/op.go

@@ -36,9 +36,6 @@ type (
 		ast.Node
 		Meta string
 	}
-	DefaultScan struct {
-		ast.Node
-	}
 	DeleteScan struct {
 		ast.Node
 		ID     ksuid.KSUID
@@ -80,7 +77,6 @@ type (
 
 func (*CommitMetaScan) opNode() {}
 func (*DBMetaScan) opNode()     {}
-func (*DefaultScan) opNode()    {}
 func (*DeleteScan) opNode()     {}
 func (*FileScan) opNode()       {}
 func (*HTTPScan) opNode()       {}
@@ -303,10 +299,6 @@ func CopyOp(op Op) Op {
 			Node: op.Node,
 			Meta: op.Meta,
 		}
-	case *DefaultScan:
-		return &DefaultScan{
-			Node: op.Node,
-		}
 	case *DeleteScan:
 		return &DeleteScan{
 			Node:   op.Node,

compiler/sfmt/dag.go

@@ -298,14 +298,6 @@ func (c *canonDAG) op(p dag.Op) {
 	case *dag.DBMetaScan:
 		c.next()
 		c.write(":%s", p.Meta)
-	case *dag.DefaultScan:
-		c.next()
-		c.write("reader")
-		if p.Filter != nil {
-			c.write(" filter (")
-			c.expr(p.Filter, "")
-			c.write(")")
-		}
 	case *dag.FileScan:
 		c.next()
 		c.write("file %s", strings.Join(p.Paths, ","))