github.com/yongjacky/phoenix-go-orm-builder@v0.3.5/cond_neq.go (about)

     1  // Copyright 2016 The Xorm Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package builder
     6  
     7  import (
     8  	"fmt"
     9  	"sort"
    10  )
    11  
    12  // Neq defines not equal conditions
    13  type Neq map[string]interface{}
    14  
    15  var _ Cond = Neq{}
    16  
    17  // WriteTo writes SQL to Writer
    18  func (neq Neq) WriteTo(w Writer) error {
    19  	var args = make([]interface{}, 0, len(neq))
    20  	var i = 0
    21  	for _, k := range neq.sortedKeys() {
    22  		v := neq[k]
    23  		switch v.(type) {
    24  		case []int, []int64, []string, []int32, []int16, []int8:
    25  			if err := NotIn(k, v).WriteTo(w); err != nil {
    26  				return err
    27  			}
    28  		case expr:
    29  			if _, err := fmt.Fprintf(w, "%s<>(", k); err != nil {
    30  				return err
    31  			}
    32  
    33  			if err := v.(expr).WriteTo(w); err != nil {
    34  				return err
    35  			}
    36  
    37  			if _, err := fmt.Fprintf(w, ")"); err != nil {
    38  				return err
    39  			}
    40  		case *Builder:
    41  			if _, err := fmt.Fprintf(w, "%s<>(", k); err != nil {
    42  				return err
    43  			}
    44  
    45  			if err := v.(*Builder).WriteTo(w); err != nil {
    46  				return err
    47  			}
    48  
    49  			if _, err := fmt.Fprintf(w, ")"); err != nil {
    50  				return err
    51  			}
    52  		default:
    53  			if _, err := fmt.Fprintf(w, "%s<>?", k); err != nil {
    54  				return err
    55  			}
    56  			args = append(args, v)
    57  		}
    58  		if i != len(neq)-1 {
    59  			if _, err := fmt.Fprint(w, " AND "); err != nil {
    60  				return err
    61  			}
    62  		}
    63  		i = i + 1
    64  	}
    65  	w.Append(args...)
    66  	return nil
    67  }
    68  
    69  // And implements And with other conditions
    70  func (neq Neq) And(conds ...Cond) Cond {
    71  	return And(neq, And(conds...))
    72  }
    73  
    74  // Or implements Or with other conditions
    75  func (neq Neq) Or(conds ...Cond) Cond {
    76  	return Or(neq, Or(conds...))
    77  }
    78  
    79  // IsValid tests if this condition is valid
    80  func (neq Neq) IsValid() bool {
    81  	return len(neq) > 0
    82  }
    83  
    84  // sortedKeys returns all keys of this Neq sorted with sort.Strings.
    85  // It is used internally for consistent ordering when generating
    86  // SQL, see https://gitea.com/xorm/builder/issues/10
    87  func (neq Neq) sortedKeys() []string {
    88  	keys := make([]string, 0, len(neq))
    89  	for key := range neq {
    90  		keys = append(keys, key)
    91  	}
    92  	sort.Strings(keys)
    93  	return keys
    94  }