xorm插入数据实例

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条插入一次。