remove quiet() and special handling for error("quiet")

book/src/SUMMARY.md

@@ -106,7 +106,6 @@
             - [has_error](super-sql/functions/errors/has_error.md)
             - [is_error](super-sql/functions/errors/is_error.md)
             - [missing](super-sql/functions/errors/missing.md)
-            - [quiet](super-sql/functions/errors/quiet.md)
         - [Generics](super-sql/functions/generics/intro.md)
             - [coalesce](super-sql/functions/generics/coalesce.md)
             - [compare](super-sql/functions/generics/compare.md)

book/src/super-sql/functions/generics/coalesce.md

@@ -32,7 +32,7 @@ values coalesce(null, error("missing"), error({x:"foo"}), this)
 # spq
 values coalesce(null, error({x:"foo"}), this)
 # input
-error("quiet")
+error("bar")
 # expected output
 null
 ```

book/src/super-sql/functions/types/nameof.md

@@ -30,18 +30,3 @@ type port=int16
 "port"
 error("missing")
 ```
-
----
-
-_The missing value can be ignored with quiet_
-
-```mdtest-spq
-# spq
-values quiet(nameof(this))
-# input
-type port=int16
-80::port
-80
-# expected output
-"port"
-```

book/src/super-sql/operators/cut.md

@@ -31,9 +31,6 @@ simple field references, the _cut_ operation resembles the Unix shell command, e
 ```
 ... | cut a,c | ...
 ```
-If an expression results in `error("quiet")`, the corresponding field is omitted
-from the output.  This allows you to wrap expressions in a `quiet()` function
-to filter out missing errors.
 
 If an input value to cut is not a record, then cut still operates as defined
 resulting in `error("missing")` for expressions that reference fields of `this`.
@@ -74,18 +71,6 @@ cut a,d
 
 ---
 
-_The missing fields can be ignored with quiet_
-```mdtest-spq
-# spq
-cut a:=quiet(a),d:=quiet(d)
-# input
-{a:1,b:2,c:3}
-# expected output
-{a:1}
-```
-
----
-
 _Non-record values generate missing errors for fields not present in a non-record `this`_
 ```mdtest-spq {data-layout="stacked"}
 # spq

book/src/super-sql/types/error.md

@@ -92,7 +92,7 @@ but having a first-class data type to manage them all while allowing them to
 peacefully coexist with valid production data is a novel and
 useful approach that SuperSQL enables.
 
-## Missing and Quiet
+## Missing
 
 SuperDB's heterogeneous data model allows for queries
 that operate over different types of data whose structure and type
@@ -146,16 +146,6 @@ values x
 error("missing")
 ```
 
-Sometimes you want missing errors to show up and sometimes you don't.
-The [`quiet`](../functions/errors/quiet.md) function transforms missing errors into
-"quiet errors".  A quiet error is the value `error("quiet")` and is ignored
-by most operators, in particular,
-[`values`](../operators/values.md), e.g.,
-```
-values error("quiet")
-```
-produces no output.
-
 ## Examples
 
 ---
@@ -205,20 +195,6 @@ typeof(1/this)
 
 ---
 
-_The `quiet` function suppresses error values_
-
-```mdtest-spq
-# spq
-values quiet(x)
-# input
-{x:1}
-{y:2}
-# expected output
-1
-```
-
----
-
 _Coalesce replaces `error("missing")` values with a default value_
 
 ```mdtest-spq

book/src/tutorials/jq.md

@@ -378,17 +378,6 @@ produces
 {val:1}
 {val:error("missing")}
 ```
-Sometimes you expect "missing" errors to occur sporadically and just want
-to ignore them, which can you easily do with the
-[quiet](../super-sql/functions/errors/quiet.md) function, e.g.,
-```mdtest-command
-echo '{s:"foo", val:1}{s:"bar"}' | super -s -c 'cut quiet(val)' -
-```
-produces
-```mdtest-output
-{val:1}
-{}
-```
 
 ### Union Types
 

compiler/parser/ztests/unnest-expr.yaml

@@ -6,7 +6,7 @@ script: |
   echo === expression
   super compile -C 'values (unnest a | ?b)'
   echo === function
-  super compile -C 'quiet((unnest a | ?b))'
+  super compile -C 'typeof((unnest a | ?b))'
   echo === grep
   super compile -C 'grep("regexp", (unnest a | ?b))'
 
@@ -30,7 +30,7 @@ outputs:
         | search b
       )
       === function
-      quiet((
+      typeof((
         unnest a
         | search b
       ))

compiler/rungen/vop.go

@@ -205,7 +205,6 @@ func (b *Builder) compileVamLeaf(o dag.Op, parent vio.Puller) (vio.Puller, error
 		if err != nil {
 			return nil, err
 		}
-		e = vamexpr.NewDequiet(b.sctx(), e)
 		return vamop.NewValues(b.sctx(), parent, []vamexpr.Evaluator{e}), nil
 	case *dag.DebugOp:
 		e, err := b.compileVamExpr(o.Expr)
@@ -268,7 +267,6 @@ func (b *Builder) compileVamLeaf(o dag.Op, parent vio.Puller) (vio.Puller, error
 		if err != nil {
 			return nil, err
 		}
-		e = vamexpr.NewDequiet(b.sctx(), e)
 		putter := vamexpr.NewPutter(b.sctx(), e)
 		return vamop.NewValues(b.sctx(), parent, []vamexpr.Evaluator{putter}), nil
 	case *dag.RenameOp:

compiler/semantic/expr.go

@@ -1008,14 +1008,11 @@ func deriveNameFromExpr(e ast.Expr) string {
 	case *ast.AggFuncExpr:
 		return e.Name
 	case *ast.CallExpr:
-		var name string
-		if f, ok := e.Func.(*ast.FuncNameExpr); ok {
-			name = f.Name
-		}
-		if strings.ToLower(name) == "quiet" && len(e.Args) > 0 {
-			return deriveNameFromExpr(e.Args[0])
+		f, ok := e.Func.(*ast.FuncNameExpr)
+		if !ok {
+			return ""
 		}
-		return name
+		return f.Name
 	case *ast.BinaryExpr:
 		if name, ok := dottedName(e); ok {
 			return name

complex.go

@@ -39,7 +39,6 @@ var ErrMissing = errors.New("missing")
 // each operator has clearly defined semantics with respect to the Missing value.
 // For example, "true AND MISSING" is MISSING.
 var Missing = scode.Bytes("missing")
-var Quiet = scode.Bytes("quiet")
 
 type TypeError struct {
 	id   int
@@ -62,10 +61,6 @@ func (t *TypeError) IsMissing(zv scode.Bytes) bool {
 	return t.Type == TypeString && bytes.Equal(zv, Missing)
 }
 
-func (t *TypeError) IsQuiet(zv scode.Bytes) bool {
-	return t.Type == TypeString && bytes.Equal(zv, Quiet)
-}
-
 type TypeEnum struct {
 	id      int
 	Symbols []string

context.go

@@ -650,12 +650,6 @@ func (c *Context) Missing() Value {
 	return NewValue(c.StringTypeError(), Missing)
 }
 
-func (c *Context) Quiet() Value {
-	return NewValue(c.StringTypeError(), Quiet)
-}
-
-// batch/allocator should handle these?
-
 func (c *Context) NewErrorf(format string, args ...any) Value {
 	return NewValue(c.StringTypeError(), fmt.Appendf(nil, format, args...))
 }

f.sql

@@ -0,0 +1,25 @@
+SELECT *
+from
+    values
+      (10,'a0'),
+      (15,'a8'),
+      (20,'a1'),
+      (25,'a7'),
+      (30,'a2'),
+      (35,'a6'),
+      (40,'a3'),
+      (45,'a5'),
+      (50,'a4'),
+      (null,'a_null')
+      l (a,sa)
+left join
+    values
+      (20,'b20.1'),
+      (20,'b20.2'),
+      (40,'b40'),
+      (40,'b40.2'),
+      (60,'b60'),
+      (null,'b_null')
+      r (b,sb)
+on l.a = r.b
+order by a

runtime/sam/expr/agg.go

@@ -39,8 +39,5 @@ func (a *Aggregator) Apply(sctx *super.Context, f agg.Function, this super.Value
 			return
 		}
 	}
-	v := a.expr.Eval(this)
-	if !v.IsQuiet() {
-		f.Consume(v)
-	}
+	f.Consume(a.expr.Eval(this))
 }

runtime/sam/expr/dropper.go

@@ -61,9 +61,6 @@ func (d *Dropper) Eval(in super.Value) super.Value {
 	if dropType == typ {
 		return in
 	}
-	if dropType == d.emptyType {
-		return d.sctx.Quiet()
-	}
 	b := &d.builder
 	b.Reset()
 	d.recode(b, typ, in.Bytes(), dropType, d.dropMap)