// AcceptNegation implements Visitor
181592
func (s *EmptyTransformer) AcceptNegation(v Negation) {
	s.Result = Negation{s.Transform(v.Operand)}
}
98837
func (n *AlterTableSpec) Accept(v Visitor) (Node, bool) {
	newNode, skipChildren := v.Enter(n)
	if skipChildren {
		return v.Leave(newNode)
	}
	n = newNode.(*AlterTableSpec)
	if n.Constraint != nil {
		node, ok := n.Constraint.Accept(v)
		if !ok {
			return n, false
		}
		n.Constraint = node.(*Constraint)
	}
	if n.NewTable != nil {
		node, ok := n.NewTable.Accept(v)
		if !ok {
			return n, false
		}
		n.NewTable = node.(*TableName)
	}
	if n.NewColumn != nil {
		node, ok := n.NewColumn.Accept(v)
		if !ok {
			return n, false
		}
		n.NewColumn = node.(*ColumnDef)
	}
	if n.OldColumnName != nil {
		node, ok := n.OldColumnName.Accept(v)
		if !ok {
			return n, false
		}
		n.OldColumnName = node.(*ColumnName)
	}
	if n.Position != nil {
		node, ok := n.Position.Accept(v)
		if !ok {
			return n, false
		}
		n.Position = node.(*ColumnPosition)
	}
	return v.Leave(n)
}
547979
func (sv *StringVisitor) AcceptNegation(v Negation) {
	sv.result += "(not "
	v.Operand.Accept(sv)
	sv.result += ")"
}
475348
func (s *numericCompilerVisitor) AcceptInclusion(v tree.Inclusion) {
	s.err = errors.New("an in-statement was found in an expression - this is likely a programmer error")
}
891711
func (n *ExecuteStmt) Accept(v Visitor) (Node, bool) {
	newNode, skipChildren := v.Enter(n)
	if skipChildren {
		return v.Leave(newNode)
	}
	n = newNode.(*ExecuteStmt)
	for i, val := range n.UsingVars {
		node, ok := val.Accept(v)
		if !ok {
			return n, false
		}
		n.UsingVars[i] = node.(ExprNode)
	}
	return v.Leave(n)
}
87826
func (h *httpForwarder) Accept() (net.Conn, error) {
	conn := <-h.connChan
	return conn, nil
}
193209
func (t *precompilationTypeChecker) AcceptInclusion(v tree.Inclusion) {
	if v.Positive {
		t.result = fmt.Errorf("no inclusion expressions allowed - this is probably a programmer error: %s", tree.ExpressionString(v))
	} else {
		t.result = fmt.Errorf("no negative inclusion expressions allowed - this is probably a programmer error: %s", tree.ExpressionString(v))
	}
}
610016
func (n *TableSource) Accept(v Visitor) (Node, bool) {
	newNode, skipChildren := v.Enter(n)
	if skipChildren {
		return v.Leave(newNode)
	}
	n = newNode.(*TableSource)
	node, ok := n.Source.Accept(v)
	if !ok {
		return n, false
	}
	n.Source = node.(ResultSetNode)
	return v.Leave(n)
}
363208
func (s *booleanSimplifier) AcceptNegation(v tree.Negation) {
	val := s.Transform(v.Operand)
	val2, ok := potentialExtractBooleanValue(val)
	if ok {
		s.Result = tree.BooleanLiteral{!val2}
	}
}
1086132
func (sv *EvaluatorVisitor) AcceptBinaryNegation(v BinaryNegation) {
	v.Operand.Accept(sv)
	sv.pushNumeric(^sv.popNumeric())
}
381216
func (sv *StringVisitor) AcceptCall(v Call) {
	sv.result += "(" + v.Name
	for _, a := range v.Args {
		sv.result += " "
		a.Accept(sv)
	}
	sv.result += ")"
}
530850
func (t *typeChecker) AcceptBinaryNegation(v tree.BinaryNegation) {
	if t.expectBoolean {
		t.result = fmt.Errorf("expected boolean expression but found: %s", tree.ExpressionString(v))
		return
	}

	res := typeCheckExpectingNumeric(v.Operand)
	if res != nil {
		t.result = res
	}
}
740994
func (n *FlushTableStmt) Accept(v Visitor) (Node, bool) {
	newNode, skipChildren := v.Enter(n)
	if skipChildren {
		return v.Leave(newNode)
	}
	n = newNode.(*FlushTableStmt)
	return v.Leave(n)
}
1323792
func (ar *argumentRestrictions) AcceptInclusion(v tree.Inclusion) {
	ar.register(checkRestrictedArgumentUsage(v.Left))
	for _, r := range v.Rights {
		ar.register(checkRestrictedArgumentUsage(r))
	}
}
113357
func (n *ColumnDef) Accept(v Visitor) (Node, bool) {
	newNode, skipChildren := v.Enter(n)
	if skipChildren {
		return v.Leave(newNode)
	}
	n = newNode.(*ColumnDef)
	node, ok := n.Name.Accept(v)
	if !ok {
		return n, false
	}
	n.Name = node.(*ColumnName)
	for i, val := range n.Options {
		node, ok := val.Accept(v)
		if !ok {
			return n, false
		}
		n.Options[i] = node.(*ColumnOption)
	}
	return v.Leave(n)
}
758566
func (t *precompilationTypeChecker) AcceptBinaryNegation(v tree.BinaryNegation) {
	t.result = fmt.Errorf("no binary negation expressions allowed - this is probably a programmer error: %s", tree.ExpressionString(v))
}
862325
func (s *arithmeticSimplifier) AcceptBinaryNegation(v tree.BinaryNegation) {
	val := s.Transform(v.Operand)
	if val2, ok := potentialExtractValue(val); ok {
		s.Result = tree.NumericLiteral{^val2}
	}
}