sectionName: slctr-expr-in-yes
  - name: gateway
    namespace: istio-system
    sectionName: slctr-expr-in-no
  - name: gateway
    namespace: istio-system
    sectionName: slctr-expr-notin-yes
  - name: gateway
    namespace: istio-system
    sectionName: slctr-expr-notin-no
  - name: gateway
    namespace: istio-system
    sectionName: slctr-expr-exists-yes
  - name: gateway

	NegationBuild(builder Builder)
}

// Expr raw expression
type Expr struct {
	SQL                string
	Vars               []interface{}
	WithoutParentheses bool
}

// Build build raw expression
func (expr Expr) Build(builder Builder) {
	var (
		afterParenthesis bool
		idx              int
	)

	for _, v := range []byte(expr.SQL) {
		if v == '?' && len(expr.Vars) > idx {

			expr:         `isIP("2001:db8::68")`,
			expectResult: trueVal,
		},
		{
			name:         "isIP invalid ipv4",
			expr:         `isIP("2001:db8:::68")`,
			expectResult: falseVal,
		},
		{
			name:         "ip.isCanonical valid ipv6",
			expr:         `ip.isCanonical("2001:db8::68")`,
			expectResult: trueVal,
		},
		{
			name:         "ip.isCanonical non-canonical ipv6",

		}
	} else {
		builder.WriteByte('*')
	}
}

func (s Select) MergeClause(clause *Clause) {
	if s.Expression != nil {
		if s.Distinct {
			if expr, ok := s.Expression.(Expr); ok {
				expr.SQL = "DISTINCT " + expr.SQL
				clause.Expression = expr
				return
			}
		}

		clause.Expression = s.Expression
	} else {
		clause.Expression = s
	}
}

const _ /* ERROR "missing init expr for _" */
const _ = 1, 2 /* ERROR "extra init expr 2" */

const _ /* ERROR "missing init expr for _" */ int
const _ int = 1, 2 /* ERROR "extra init expr 2" */

const (
	_ /* ERROR "missing init expr for _" */
	_ = 1, 2 /* ERROR "extra init expr 2" */

	_ /* ERROR "missing init expr for _" */ int
	_ int = 1, 2 /* ERROR "extra init expr 2" */
)

const (
	_ = 1
	_

        data class Failed(val errors: Collection<DocumentError>) : ExprConversion
    }


    private
    fun exprToValue(expr: Expr): ExprConversion = when (expr) {
        is Literal<*> -> ExprConversion.Converted(literalNode(expr))
        is FunctionCall -> run {
            val errors = mutableListOf<DocumentError>()

                && value.getClass().getName().startsWith("java.lang."));
    }

    private String stripTokens(String expr) {
        if (expr.startsWith("${") && (expr.indexOf('}') == expr.length() - 1)) {
            expr = expr.substring(2, expr.length() - 1);
        }
        return expr;
    }

    @Override
    public File alignToBaseDirectory(File file) {

		}
	}

	var buf bytes.Buffer

	var expr string
	if x.expr != nil {
		expr = ExprString(x.expr)
	} else {
		switch x.mode {
		case builtin:
			expr = predeclaredFuncs[x.id].name
		case typexpr:
			expr = TypeString(x.typ, qf)
		case constant_:
			expr = x.val.String()
		}
	}

	// <expr> (
	if expr != "" {
		buf.WriteString(expr)
		buf.WriteString(" (")
	}

}


sealed interface FunctionArgument : LanguageTreeElement {
    sealed interface ValueArgument : FunctionArgument {
        val expr: Expr
    }

    data class Positional(override val expr: Expr, override val sourceData: SourceData) : ValueArgument
    data class Named(val name: String, override val expr: Expr, override val sourceData: SourceData) : ValueArgument

               },
               "expr": "sum by (pod) (\n  container_memory_working_set_bytes{container=\"discovery\", pod=~\"istiod-.*\"}\n)",
               "legendFormat": "Container ({{pod}})"
            },
            {
               "datasource": {
                  "type": "prometheus",
                  "uid": "$datasource"
               },