package main

import (
  "fmt"
  _ "github.com/go-sql-driver/mysql"
  "github.com/go-xorm/xorm"
  "log"
)

var engine *xorm.Engine



type User2 struct {
  Name string `xorm:"varchar(25) 'usr_name'"`
  Id   int    `xorm:"pk 'id' autoincr"`
}


type User3 struct {
  Name string `xorm:"varchar(25) 'usr_name'"`
  Id   int    `xorm:"pk 'id' autoincr"`
}



func main() {
  var err error
  engine, err = xorm.NewEngine("mysql", "root:123456@/test")
  if err != nil {
      log.Fatal(err)
      return
  }


  err = engine.CreateTables(User2{})
  if err!=nil {
      log.Fatal(err)
      return
  }

  err = engine.CreateTables(User3{})
  if err!=nil {
      log.Fatal(err)
      return
  }



  //func (engine *Engine) Insert(beans ...interface{}) (int64, error)
  //返回的第一个参数是受影响的行数
  //插入一条数据，可以用Insert
  stu:= new(User2)
  stu.Name ="user"
  affected ,err :=engine.Insert(stu)
  if err!=nil {
      log.Fatal(err)
      return
  }
  fmt.Println("插入一条数据用Insert受影响的行数：",affected)

  //插入一条数据，也可以用InsertOne
  stu1:= new(User2)
  stu1.Name="user2222"
  affected ,err =engine.InsertOne(stu1)
  if err!=nil {
      log.Fatal(err)
      return
  }
  fmt.Println("InsertOne受影响的行数：",affected)


/*    插入同一个表的多条数据，
  此时如果数据库支持批量插入，那么会进行批量插入，
  但是这样每条记录就无法被自动赋予id值。
  如果数据库不支持批量插入，那么就会一条一条插入。*/
  sts:=make([]User2,3)
  sts[0].Name ="name"
  sts[1].Name ="name"
  sts[2].Name ="name"

  affected,err = engine.Insert(sts)
  if err !=nil {
      log.Fatal(err)
      return
  }
  fmt.Println("插入同一个表的多条数据受影响的行数：",affected)
      //使用指针Slice插入多条记录，同上
  stus:=make([]*User2,3)
  stus[0] =new(User2)
  stus[0].Name="name"
  stus[1] =new(User2)
  stus[1].Name="name"
  stus[2] =new(User2)
  stus[2].Name="name"

  affected,err = engine.Insert(stus)
  if err !=nil {
      log.Fatal(err)
      return
  }

  fmt.Println("使用指针Slice插入多条记录受影响的行数：",affected)

//插入不同表的一条记录
  s := new(User2)
  s.Name="s"
  s1:= new(User3)
  s1.Name="s1"
  affected,err = engine.Insert(s,s1)
  if err !=nil {
      log.Fatal(err)
      return
  }

  fmt.Println("插入不同表的一条记录受影响的行数：",affected)


  //插入不同表的多条记录
  ss:=make([]User2,3)
  ss[0].Name ="name"
  ss[1].Name ="name"
  ss[2].Name ="name"

  ss1:=make([]User3,2)
  ss1[0].Name ="name"
  ss1[1].Name ="name"

  affected,err = engine.Insert(ss,ss1)
  if err !=nil {
      log.Fatal(err)
      return
  }
  fmt.Println("插入不同表的多条记录受影响的行数：",affected)


  //插入不同表的一条或多条记录
  s0:= new(User2)
  s0.Name="s0"

  ss0:=make([]User3,2)
  ss1[0].Name ="name"
  ss1[1].Name ="name"

  affected,err = engine.Insert(s0,ss0)
  if err !=nil {
      log.Fatal(err)
      return
  }
  fmt.Println("插入不同表的一条或多条记录受影响的行数：",affected)

}

/*输出:
插入一条数据用Insert受影响的行数： 1
InsertOne受影响的行数： 1
插入同一个表的多条数据受影响的行数： 3
使用指针Slice插入多条记录受影响的行数： 3
插入不同表的一条记录受影响的行数： 2
插入不同表的多条记录受影响的行数： 5
插入不同表的一条或多条记录受影响的行数： 3
*/

这里需要注意以下几点：

• 这里虽然支持同时插入，但这些插入并没有事务关系。因此有可能在中间插入出错后，后面的插入将不会继续。此时前面的插入已经成功，如果需要回滚，请开启事务。
• 批量插入会自动生成Insert into table values (),(),()的语句，因此各个数据库对SQL语句有长度限制，因此这样的语句有一个最大的记录数，根据经验测算在150条左右。大于150条后，生成的sql语句将太长可能导致执行失败。因此在插入大量数据时，目前需要自行分割成每150条插入一次。