add -- args passing from shell as const args in query

book/src/command/super.md

@@ -17,7 +17,7 @@ Instead, your shell is your REPL and the `super` command lets you:
 
 The `super` command is invoked either by itself to run a query:
 ```
-super [ -c <query> | -I <query-file> ] [ options ] [ <path> ... ]
+super [ -c <query> | -I <query-file> ] [ options ] [ <path> ... ] [ -- [ <arg> ... ]]
 ```
 or with a [sub-command](sub-commands.md):
 ```
@@ -32,6 +32,17 @@ SuperDB query engine detached from the database storage layer.
 
 The [input data](input.md) may be specified as command-line paths or
 referenced within the query.
+One or more `<path>` arguments act as if a
+[from](../super-sql/operators/from.md) operator has been prepended to
+the query specified.  When no query is specified,
+the inputs are scanned with no query applied.
+
+Arguments may be passed from the command-line into the query using
+`--` to terminate the input path specifications and indicate subsequent query arguments.
+All of the shell arguments after `--` are assembled into a string array
+called `args` as a
+[constant](../super-sql/declarations/constants.md)
+appearing in the main scope of the query.
 
 For built-in command help and a listing of all available options,
 simply run `super` without any arguments.

cmd/super/root/command.go

@@ -84,7 +84,7 @@ func (c *Command) Run(args []string) error {
 		return nil
 	}
 	if len(args) > 0 {
-		ast.PrependFileScan(args)
+		args = ast.PrependFileScan(args)
 	}
 	env := exec.NewEnvironment(storage.NewLocalEngine(), nil)
 	env.Dynamic = c.inputFlags.Dynamic

cmd/super/ztests/command-args.yaml

@@ -0,0 +1,51 @@
+script: |
+  super -s -c "values args" -- a b c
+
+outputs:
+  - name: stdout
+    data: |
+      ["a","b","c"]
+
+---
+
+script: |
+  super -s -c "values args" --
+
+outputs:
+  - name: stdout
+    data: |
+      []
+
+---
+
+script: |
+  super -s -c "values args" in.sup --
+
+inputs:
+  - name: in.sup
+    data: |
+      null
+      null
+
+outputs:
+  - name: stdout
+    data: |
+      []
+      []
+
+---
+
+script: |
+  super -s -c "values args" - --
+
+inputs:
+  - name: stdin
+    data: |
+      null
+      null
+
+outputs:
+  - name: stdout
+    data: |
+      []
+      []

compiler/ast/value.go

@@ -24,11 +24,10 @@ func (*Decorated) valueNode()  {}
 
 type (
 	Primitive struct {
-		Kind    string `json:"kind" unpack:""`
-		Type    string `json:"type"`
-		Text    string `json:"text"`
-		TextPos int    `json:"text_pos"`
-		Loc     `json:"loc"`
+		Kind string `json:"kind" unpack:""`
+		Type string `json:"type"`
+		Text string `json:"text"`
+		Loc  `json:"loc"`
 	}
 	Record struct {
 		Kind   string  `json:"kind" unpack:""`

compiler/parser/api.go

@@ -2,6 +2,7 @@ package parser
 
 import (
 	"errors"
+	"slices"
 
 	"github.com/brimdata/super/compiler/ast"
 	"github.com/brimdata/super/compiler/srcfiles"
@@ -36,11 +37,50 @@ func (a *AST) ConvertToDeleteWhere(pool, branch string) error {
 	return nil
 }
 
-func (a *AST) PrependFileScan(paths []string) {
-	a.seq.Prepend(&ast.FileScan{
-		Kind:  "FileScan",
-		Paths: paths,
-	})
+func (a *AST) PrependFileScan(paths []string) []string {
+	var args []string
+	if k := slices.Index(paths, "--"); k >= 0 {
+		args = paths[k+1:]
+		paths = paths[:k]
+	}
+	if len(paths) > 0 {
+		a.seq.Prepend(&ast.FileScan{
+			Kind:  "FileScan",
+			Paths: paths,
+		})
+	}
+	if args != nil {
+		a.seq = []ast.Op{
+			&ast.ScopeOp{
+				Kind: "ScopeOp",
+				Decls: []ast.Decl{
+					&ast.ConstDecl{
+						Kind: "ConstDecl",
+						Name: &ast.ID{Name: "args"},
+						Expr: stringArray(args),
+					},
+				},
+				Body: a.seq,
+			},
+		}
+	}
+	return paths
+}
+
+func stringArray(in []string) ast.Expr {
+	var elems []ast.ArrayElem
+	for _, s := range in {
+		e := &ast.Primitive{
+			Kind: "Primitive",
+			Type: "string",
+			Text: s,
+		}
+		elems = append(elems, &ast.ExprElem{Kind: "ExprElem", Expr: e})
+	}
+	return &ast.ArrayExpr{
+		Kind:  "ArrayExpr",
+		Elems: elems,
+	}
 }
 
 // ParseText parses a query text in string form.

pkg/charm/instance.go

@@ -3,6 +3,7 @@ package charm
 import (
 	"flag"
 	"fmt"
+	"slices"
 	"sort"
 	"strings"
 )
@@ -77,17 +78,26 @@ func parse(spec *Spec, args []string, parent Command, interiorLeaf int) (path, [
 		}
 		path = append(path, component)
 		parent = cmd
+		// These gymnastics prevent Go flags from stopping at and consuming the "--"
+		// and retains it as remaining args, which lets us implement args options
+		// passed to the query with "... -- arg arg"
+		savedArgs := args
+		var dashDashArgs []string
+		if k := slices.Index(args, "--"); k >= 0 {
+			dashDashArgs = args[k:]
+			args = args[:k]
+		}
 		if err := flags.Parse(args); err != nil {
 			if usage {
-				s := strings.Join(args, " ")
+				s := strings.Join(savedArgs, " ")
 				err = fmt.Errorf("at flag: %q: %w", s, err)
 			}
 			return path, nil, false, err
 		}
 		if help {
 			return path, nil, hidden, NeedHelp
 		}
-		rest := flags.Args()
+		rest := append(flags.Args(), dashDashArgs...)
 		if len(rest) != 0 {
 			spec = component.spec.lookupSub(rest[0])
 			if spec != nil {