xorm -Alias，Asc，Desc方法实例

• Alias(string)给Table设定一个别名

  package main
  
  import (
  	"fmt"
  	_ "github.com/go-sql-driver/mysql"
  	"github.com/go-xorm/xorm"
  	"log"
  	"time"
  )
  
  var engine *xorm.Engine
  
  type User struct {
  	Name string `xorm:"varchar(25) 'name'"`
  	Id   int    `xorm:"pk 'id' autoincr"`
  	CreatedAt time.Time `xorm:"created"`
  }
  
  func main() {
  	var err error
  	engine, err = xorm.NewEngine("mysql", "root:123456@/test")
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  	err = engine.CreateTables(User{})
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  //插入数据部分
  	u := make([]User,3)
  	u[0].Name="u0"
  	u[1].Name="u1"
  
  	_, err = engine.Insert(u)
  	if err!=nil {
  		log.Fatal(err)
  		return
  	}
  
  	uu :=new(User)
  
  	//查询结果为空
  	has,err := engine.Alias("alias") .Where("alias.name = ?","u").Get(uu)
  	if err!=nil{
  		log.Fatal(err)
  		return
  	}
  	fmt.Println("要查询的name是u的数据是否在数据库里：",has)
  	if has {
  		fmt.Println("uid:",uu.Id," uname:" ,uu.Name," utime:",uu.CreatedAt)
  	}
  
  	// 一个查询条件
  	has,err = engine.Alias("alias") .Where("alias.name = ?","u0").Get(uu)
  	if err!=nil{
  		log.Fatal(err)
  		return
  	}
  	fmt.Println("name是u0的数据是否在数据库里",has)
  	if has {
  		fmt.Println("    name是u0的数据在数据库里，而且他的uid:",uu.Id," uname:" ,uu.Name," utime:",uu.CreatedAt)
  	}
  
  	//and条件查询
  	has,err = engine.Alias("alias") .Where("alias.name = ?","u0").And("alias.id =?","1").Get(uu)
  	if err!=nil{
  		log.Fatal(err)
  		return
  	}
  	fmt.Println("name为u0，id为1的数据是否在数据库里",has)
  	if has {
  		fmt.Println("     name为u0，id为1的数据在数据库里，而且他的uid:",uu.Id," uname:" ,uu.Name," utime:",uu.CreatedAt)
  	}
  
  	//or条件查询
  	has,err = engine.Alias("alias") .Where("alias.name = ?","u0").Or("alias.name =?","u").Get(uu)
  	if err!=nil{
  		log.Fatal(err)
  		return
  	}
  	fmt.Println("name为u0或者为u的数据在数据库里",has)
  	if has {
  		fmt.Println("     name为u0或者为u的数据在数据库里，而且他的uid:",uu.Id," uname:" ,uu.Name," utime:",uu.CreatedAt)
  	}
  	/*
  	    输出：
  			要查询的name是u的数据是否在数据库里： false
  			name是u0的数据是否在数据库里 true
  				name是u0的数据在数据库里，而且他的uid: 6  uname: u0  utime: 2019-05-26 14:17:51 +0800 CST
  			name为u0，id为1的数据是否在数据库里 false
  			name为u0或者为u的数据在数据库里 true
  				 name为u0或者为u的数据在数据库里，而且他的uid: 6  uname: u0  utime: 2019-05-26 14:17:51 +0800 CST
  
  	*/
  
  }
  

• Asc(…string)指定字段名正序排序/Desc(…string)指定字段名逆序排序

  package main
  
  import (
  	"fmt"
  	_ "github.com/go-sql-driver/mysql"
  	"github.com/go-xorm/xorm"
  	"log"
  	"time"
  )
  
  var engine *xorm.Engine
  
  type User struct {
  	Name      string    `xorm:"varchar(25) 'name'"`
  	Id        int       `xorm:"pk 'id' autoincr"`
  	CreatedAt time.Time `xorm:"created"`
  }
  
  func main() {
  	var err error
  	engine, err = xorm.NewEngine("mysql", "root:123456@/test")
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  	err = engine.CreateTables(User{})
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  /*	u := make([]User, 5)
  	u[0].Name = "abcd"
  	u[1].Name = "acbd"
  	u[2].Name = "dbac"
  	u[3].Name = "cbda"
  	u[4].Name = "bdca"
  
  	_, err = engine.Insert(u)
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  */
  	re := make([]User, 0)
  
  	fmt.Println("升序之前:")
  	err = engine.Find(&re)
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  	for i, r := range re {
  		fmt.Println("    index:", i, " rName:", r.Name)
  	}
  
  	re1 := make([]User, 0)
  	fmt.Println("====================升序之后：")
  	err = engine.Asc("name").Find(&re1)
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  	for i, r := range re1 {
  		fmt.Println("    index:", i, " rName:", r.Name)
  	}
  
  	fmt.Println("======================降序之后：")
  	re2 := make([]User, 0)
  	err = engine.Desc("name").Find(&re2)
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  	for i, r := range re2 {
  		fmt.Println("    index:", i, " rName:", r.Name)
  	}
  
  	fmt.Println("======================ORDERBY：")
  	re3 := make([]User, 0)
  	err = engine.OrderBy("name").Find(&re3)
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  	for i, r := range re3 {
  		fmt.Println("    index:", i, " rName:", r.Name)
  	}
  
  	fmt.Println("======================DESC：")
  	re4 := make([]User, 0)
  	err = engine.Desc("name").Find(&re4)
  	if err != nil {
  		log.Fatal(err)
  		return
  	}
  
  	for i, r := range re4 {
  		fmt.Println("    index:", i, " rName:", r.Name)
  	}
  }
  
  /*
  输出：
  升序之前:
  index: 0  rName: abcd
  index: 1  rName: acbd
  index: 2  rName: dbac
  index: 3  rName: cbda
  index: 4  rName: bdca
  ====================升序之后：
  index: 0  rName: abcd
  index: 1  rName: acbd
  index: 2  rName: bdca
  index: 3  rName: cbda
  index: 4  rName: dbac
  ======================降序之后：
  index: 0  rName: dbac
  index: 1  rName: cbda
  index: 2  rName: bdca
  index: 3  rName: acbd
  index: 4  rName: abcd
  ======================ORDERBY：
  index: 0  rName: abcd
  index: 1  rName: acbd
  index: 2  rName: bdca
  index: 3  rName: cbda
  index: 4  rName: dbac
  ======================DESC：
  index: 0  rName: dbac
  index: 1  rName: cbda
  index: 2  rName: bdca
  index: 3  rName: acbd
  index: 4  rName: abcd
  */