init project
This commit is contained in:
Lunny Xiao
commit
4969e8bf94
|
|
@ -0,0 +1,22 @@
|
|||
# Compiled Object files, Static and Dynamic libs (Shared Objects)
|
||||
*.o
|
||||
*.a
|
||||
*.so
|
||||
|
||||
# Folders
|
||||
_obj
|
||||
_test
|
||||
|
||||
# Architecture specific extensions/prefixes
|
||||
*.[568vq]
|
||||
[568vq].out
|
||||
|
||||
*.cgo1.go
|
||||
*.cgo2.c
|
||||
_cgo_defun.c
|
||||
_cgo_gotypes.go
|
||||
_cgo_export.*
|
||||
|
||||
_testmain.go
|
||||
|
||||
*.exe
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
orm
|
||||
=====
|
||||
|
||||
orm is an ORM for Go. It lets you map Go structs to tables in a database.
|
||||
|
||||
Right now, it interfaces with Mysql/SQLite. The goal however is to add support for PostgreSQL/DB2/MS ADODB/ODBC/Oracle in the future.
|
||||
|
||||
All in all, it's not entirely ready for advanced use yet, but it's getting there.
|
||||
|
||||
Drivers for Go's sql package which support database/sql includes:
|
||||
|
||||
Mysql:[github.com/ziutek/mymysql/godrv](https://github.com/ziutek/mymysql/godrv)
|
||||
|
||||
Mysql:[github.com/Go-SQL-Driver/MySQL](https://github.com/Go-SQL-Driver/MySQL)
|
||||
|
||||
SQLite:[github.com/mattn/go-sqlite3](https://github.com/mattn/go-sqlite3)
|
||||
|
||||
### Installing xorm
|
||||
go get github.com/lunny/xorm
|
||||
|
||||
### Quick Start
|
||||
|
||||
1. Create an database engine (for example: mysql)
|
||||
|
||||
```go
|
||||
engine := xorm.Create("mysql://root:123@localhost/test")
|
||||
```
|
||||
|
||||
2. Define your struct
|
||||
|
||||
```go
|
||||
type User struct {
|
||||
Id int
|
||||
Name string
|
||||
Age int `xorm:"-"`
|
||||
}
|
||||
```
|
||||
|
||||
for Simple Task, just use engine's functions:
|
||||
|
||||
begin start, you should create a database and then we create the tables
|
||||
|
||||
```go
|
||||
err := engine.CreateTables(&User{})
|
||||
```
|
||||
|
||||
then, insert an struct to table
|
||||
|
||||
```go
|
||||
id, err := engine.Insert(&User{Name:"lunny"})
|
||||
```
|
||||
|
||||
or you want to update this struct
|
||||
|
||||
```go
|
||||
user := User{Id:1, Name:"xlw"}
|
||||
rows, err := engine.Update(&user)
|
||||
```
|
||||
|
||||
3. Fetch a single object by user
|
||||
```go
|
||||
var user = User{Id:27}
|
||||
engine.Get(&user)
|
||||
|
||||
var user = User{Name:"xlw"}
|
||||
engine.Get(&user)
|
||||
```
|
||||
|
||||
for deep use, you should create a session, this func will create a connection to db
|
||||
|
||||
```go
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
```
|
||||
|
||||
1. Fetch a single object by where
|
||||
```go
|
||||
var user Userinfo
|
||||
session.Where("id=?", 27).Get(&user)
|
||||
|
||||
var user2 Userinfo
|
||||
session.Where(3).Get(&user2) // this is shorthand for the version above
|
||||
|
||||
var user3 Userinfo
|
||||
session.Where("name = ?", "john").Get(&user3) // more complex query
|
||||
|
||||
var user4 Userinfo
|
||||
session.Where("name = ? and age < ?", "john", 88).Get(&user4) // even more complex
|
||||
```
|
||||
|
||||
2. Fetch multiple objects
|
||||
|
||||
```go
|
||||
var allusers []Userinfo
|
||||
err := session.Where("id > ?", "3").Limit(10,20).Find(&allusers) //Get id>3 limit 10 offset 20
|
||||
|
||||
var tenusers []Userinfo
|
||||
err := session.Where("id > ?", "3").Limit(10).Find(&tenusers) //Get id>3 limit 10 if omit offset the default is 0
|
||||
|
||||
var everyone []Userinfo
|
||||
err := session.Find(&everyone)
|
||||
```
|
||||
|
||||
###***About Map Rules***
|
||||
1. Struct and struct's fields name should be Pascal style, and the table and column's name default is us
|
||||
for example:
|
||||
The structs Name 'UserInfo' will turn into the table name 'user_info', the same as the keyname.
|
||||
If the keyname is 'UserName' will turn into the select colum 'user_name'
|
||||
|
||||
2. You have two method to change the rule. One is implement your own Map interface according IMapper, you can find the interface in mapper.go and set it to engine.Mapper
|
||||
|
||||
another is use field tag, field tag support the below keywords:
|
||||
[name] column name
|
||||
pk the field is a primary key
|
||||
int(11)/varchar(50) column type
|
||||
autoincr auto incrment
|
||||
[not ]null if column can be null value
|
||||
unique unique
|
||||
- this field is not map as a table column
|
||||
|
||||
## LICENSE
|
||||
|
||||
BSD License
|
||||
[http://creativecommons.org/licenses/BSD/](http://creativecommons.org/licenses/BSD/)
|
||||
|
|
@ -0,0 +1,435 @@
|
|||
package xorm
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type SQLType struct {
|
||||
Name string
|
||||
DefaultLength int
|
||||
}
|
||||
|
||||
var (
|
||||
Int = SQLType{"int", 11}
|
||||
Char = SQLType{"char", 1}
|
||||
Varchar = SQLType{"varchar", 50}
|
||||
Date = SQLType{"date", 24}
|
||||
Decimal = SQLType{"decimal", 26}
|
||||
Float = SQLType{"float", 31}
|
||||
Double = SQLType{"double", 31}
|
||||
)
|
||||
|
||||
const (
|
||||
PQSQL = "pqsql"
|
||||
MSSQL = "mssql"
|
||||
SQLITE = "sqlite"
|
||||
MYSQL = "mysql"
|
||||
MYMYSQL = "mymysql"
|
||||
)
|
||||
|
||||
type Column struct {
|
||||
Name string
|
||||
FieldName string
|
||||
SQLType SQLType
|
||||
Length int
|
||||
Nullable bool
|
||||
Default string
|
||||
IsUnique bool
|
||||
IsPrimaryKey bool
|
||||
AutoIncrement bool
|
||||
}
|
||||
|
||||
type Table struct {
|
||||
Name string
|
||||
Type reflect.Type
|
||||
Columns map[string]Column
|
||||
PrimaryKey string
|
||||
}
|
||||
|
||||
func (table *Table) ColumnStr() string {
|
||||
colNames := make([]string, 0)
|
||||
for _, col := range table.Columns {
|
||||
if col.Name == "" {
|
||||
continue
|
||||
}
|
||||
colNames = append(colNames, col.Name)
|
||||
}
|
||||
return strings.Join(colNames, ", ")
|
||||
}
|
||||
|
||||
func (table *Table) PlaceHolders() string {
|
||||
colNames := make([]string, 0)
|
||||
for _, col := range table.Columns {
|
||||
if col.Name == "" {
|
||||
continue
|
||||
}
|
||||
colNames = append(colNames, "?")
|
||||
}
|
||||
return strings.Join(colNames, ", ")
|
||||
}
|
||||
|
||||
func (table *Table) PKColumn() Column {
|
||||
return table.Columns[table.PrimaryKey]
|
||||
}
|
||||
|
||||
type Engine struct {
|
||||
Mapper IMapper
|
||||
Protocol string
|
||||
UserName string
|
||||
Password string
|
||||
Host string
|
||||
Port int
|
||||
DBName string
|
||||
Charset string
|
||||
Others string
|
||||
Tables map[string]Table
|
||||
AutoIncrement string
|
||||
ShowSQL bool
|
||||
QuoteIdentifier string
|
||||
}
|
||||
|
||||
func (e *Engine) OpenDB() (db *sql.DB, err error) {
|
||||
db = nil
|
||||
err = nil
|
||||
if e.Protocol == "sqlite" {
|
||||
// 'sqlite:///foo.db'
|
||||
db, err = sql.Open("sqlite3", e.Others)
|
||||
// 'sqlite:///:memory:'
|
||||
} else if e.Protocol == "mysql" {
|
||||
// 'mysql://<username>:<passwd>@<host>/<dbname>?charset=<encoding>'
|
||||
connstr := strings.Join([]string{e.UserName, ":",
|
||||
e.Password, "@tcp(", e.Host, ":3306)/", e.DBName, "?charset=", e.Charset}, "")
|
||||
db, err = sql.Open(e.Protocol, connstr)
|
||||
} else if e.Protocol == "mymysql" {
|
||||
// DBNAME/USER/PASSWD
|
||||
connstr := strings.Join([]string{e.DBName, e.UserName, e.Password}, "/")
|
||||
db, err = sql.Open(e.Protocol, connstr)
|
||||
// unix:SOCKPATH*DBNAME/USER/PASSWD
|
||||
// unix:SOCKPATH,OPTIONS*DBNAME/USER/PASSWD
|
||||
// tcp:ADDR*DBNAME/USER/PASSWD
|
||||
// tcp:ADDR,OPTIONS*DBNAME/USER/PASSWD
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (engine *Engine) MakeSession() (session Session, err error) {
|
||||
db, err := engine.OpenDB()
|
||||
if err != nil {
|
||||
return Session{}, err
|
||||
}
|
||||
if engine.Protocol == "pgsql" {
|
||||
engine.QuoteIdentifier = "\""
|
||||
session = Session{Engine: engine, Db: db, ParamIteration: 1}
|
||||
} else if engine.Protocol == "mssql" {
|
||||
engine.QuoteIdentifier = ""
|
||||
session = Session{Engine: engine, Db: db, ParamIteration: 1}
|
||||
} else {
|
||||
engine.QuoteIdentifier = "`"
|
||||
session = Session{Engine: engine, Db: db, ParamIteration: 1}
|
||||
}
|
||||
session.Mapper = engine.Mapper
|
||||
session.Init()
|
||||
return
|
||||
}
|
||||
|
||||
func (sqlType SQLType) genSQL(length int) string {
|
||||
if sqlType == Date {
|
||||
return " datetime "
|
||||
}
|
||||
return sqlType.Name + "(" + strconv.Itoa(length) + ")"
|
||||
}
|
||||
|
||||
func (e *Engine) genCreateSQL(table *Table) string {
|
||||
sql := "CREATE TABLE IF NOT EXISTS `" + table.Name + "` ("
|
||||
//fmt.Println(session.Mapper.Obj2Table(session.PrimaryKey))
|
||||
for _, col := range table.Columns {
|
||||
if col.Name != "" {
|
||||
sql += "`" + col.Name + "` " + col.SQLType.genSQL(col.Length) + " "
|
||||
if col.Nullable {
|
||||
sql += " NULL "
|
||||
} else {
|
||||
sql += " NOT NULL "
|
||||
}
|
||||
//fmt.Println(key)
|
||||
if col.IsPrimaryKey {
|
||||
sql += "PRIMARY KEY "
|
||||
}
|
||||
if col.AutoIncrement {
|
||||
sql += e.AutoIncrement + " "
|
||||
}
|
||||
if col.IsUnique {
|
||||
sql += "Unique "
|
||||
}
|
||||
sql += ","
|
||||
}
|
||||
}
|
||||
sql = sql[:len(sql)-2] + ");"
|
||||
if e.ShowSQL {
|
||||
fmt.Println(sql)
|
||||
}
|
||||
return sql
|
||||
}
|
||||
|
||||
func (e *Engine) genDropSQL(table *Table) string {
|
||||
sql := "DROP TABLE IF EXISTS `" + table.Name + "`;"
|
||||
if e.ShowSQL {
|
||||
fmt.Println(sql)
|
||||
}
|
||||
return sql
|
||||
}
|
||||
|
||||
func Type(bean interface{}) reflect.Type {
|
||||
sliceValue := reflect.Indirect(reflect.ValueOf(bean))
|
||||
return reflect.TypeOf(sliceValue.Interface())
|
||||
}
|
||||
|
||||
func Type2SQLType(t reflect.Type) (st SQLType) {
|
||||
switch k := t.Kind(); k {
|
||||
case reflect.Int, reflect.Int32, reflect.Int64:
|
||||
st = Int
|
||||
case reflect.String:
|
||||
st = Varchar
|
||||
case reflect.Struct:
|
||||
if t == reflect.TypeOf(time.Time{}) {
|
||||
st = Date
|
||||
}
|
||||
default:
|
||||
st = Varchar
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
/*
|
||||
map an object into a table object
|
||||
*/
|
||||
func (engine *Engine) MapOne(bean interface{}) Table {
|
||||
t := Type(bean)
|
||||
return engine.MapType(t)
|
||||
}
|
||||
|
||||
func (engine *Engine) MapType(t reflect.Type) Table {
|
||||
table := Table{Name: engine.Mapper.Obj2Table(t.Name()), Type: t}
|
||||
table.Columns = make(map[string]Column)
|
||||
var pkCol *Column = nil
|
||||
var pkstr = ""
|
||||
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
tag := t.Field(i).Tag
|
||||
ormTagStr := tag.Get("xorm")
|
||||
var col Column
|
||||
fieldType := t.Field(i).Type
|
||||
|
||||
if ormTagStr != "" {
|
||||
col = Column{FieldName: t.Field(i).Name}
|
||||
ormTagStr = strings.ToLower(ormTagStr)
|
||||
tags := strings.Split(ormTagStr, " ")
|
||||
// TODO:
|
||||
if len(tags) > 0 {
|
||||
if tags[0] == "-" {
|
||||
continue
|
||||
}
|
||||
for j, key := range tags {
|
||||
switch k := strings.ToLower(key); k {
|
||||
case "pk":
|
||||
col.IsPrimaryKey = true
|
||||
pkCol = &col
|
||||
case "null":
|
||||
col.Nullable = (tags[j-1] != "not")
|
||||
case "autoincr":
|
||||
col.AutoIncrement = true
|
||||
case "default":
|
||||
col.Default = tags[j+1]
|
||||
case "int":
|
||||
col.SQLType = Int
|
||||
case "not":
|
||||
default:
|
||||
col.Name = k
|
||||
}
|
||||
}
|
||||
if col.SQLType.Name == "" {
|
||||
col.SQLType = Type2SQLType(fieldType)
|
||||
col.Length = col.SQLType.DefaultLength
|
||||
}
|
||||
|
||||
if col.Name == "" {
|
||||
col.Name = engine.Mapper.Obj2Table(t.Field(i).Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if col.Name == "" {
|
||||
sqlType := Type2SQLType(fieldType)
|
||||
col = Column{engine.Mapper.Obj2Table(t.Field(i).Name), t.Field(i).Name, sqlType,
|
||||
sqlType.DefaultLength, true, "", false, false, false}
|
||||
}
|
||||
table.Columns[col.Name] = col
|
||||
if strings.ToLower(t.Field(i).Name) == "id" {
|
||||
pkstr = col.Name
|
||||
}
|
||||
}
|
||||
|
||||
if pkCol == nil {
|
||||
if pkstr != "" {
|
||||
col := table.Columns[pkstr]
|
||||
col.IsPrimaryKey = true
|
||||
col.AutoIncrement = true
|
||||
col.Nullable = false
|
||||
col.Length = Int.DefaultLength
|
||||
table.PrimaryKey = col.Name
|
||||
}
|
||||
} else {
|
||||
table.PrimaryKey = pkCol.Name
|
||||
}
|
||||
|
||||
return table
|
||||
}
|
||||
|
||||
func (engine *Engine) Map(beans ...interface{}) (e error) {
|
||||
for _, bean := range beans {
|
||||
//t := getBeanType(bean)
|
||||
tableName := engine.Mapper.Obj2Table(StructName(bean))
|
||||
if _, ok := engine.Tables[tableName]; !ok {
|
||||
table := engine.MapOne(bean)
|
||||
engine.Tables[table.Name] = table
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (engine *Engine) UnMap(beans ...interface{}) (e error) {
|
||||
for _, bean := range beans {
|
||||
//t := getBeanType(bean)
|
||||
tableName := engine.Mapper.Obj2Table(StructName(bean))
|
||||
if _, ok := engine.Tables[tableName]; ok {
|
||||
delete(engine.Tables, tableName)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (e *Engine) DropAll() error {
|
||||
session, err := e.MakeSession()
|
||||
session.Begin()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, table := range e.Tables {
|
||||
sql := e.genDropSQL(&table)
|
||||
_, err = session.Exec(sql)
|
||||
if err != nil {
|
||||
session.Rollback()
|
||||
break
|
||||
}
|
||||
}
|
||||
session.Commit()
|
||||
return err
|
||||
}
|
||||
|
||||
func (e *Engine) CreateTables(beans ...interface{}) error {
|
||||
session, err := e.MakeSession()
|
||||
session.Begin()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, bean := range beans {
|
||||
table := e.MapOne(bean)
|
||||
e.Tables[table.Name] = table
|
||||
sql := e.genCreateSQL(&table)
|
||||
_, err = session.Exec(sql)
|
||||
if err != nil {
|
||||
session.Rollback()
|
||||
break
|
||||
}
|
||||
}
|
||||
session.Commit()
|
||||
return err
|
||||
}
|
||||
|
||||
func (e *Engine) CreateAll() error {
|
||||
session, err := e.MakeSession()
|
||||
session.Begin()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, table := range e.Tables {
|
||||
sql := e.genCreateSQL(&table)
|
||||
_, err = session.Exec(sql)
|
||||
if err != nil {
|
||||
session.Rollback()
|
||||
break
|
||||
}
|
||||
}
|
||||
session.Commit()
|
||||
return err
|
||||
}
|
||||
|
||||
func (engine *Engine) Insert(beans ...interface{}) (int64, error) {
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
|
||||
return session.Insert(beans...)
|
||||
}
|
||||
|
||||
func (engine *Engine) Update(bean interface{}) (int64, error) {
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
|
||||
return session.Update(bean)
|
||||
}
|
||||
|
||||
func (engine *Engine) Delete(bean interface{}) (int64, error) {
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
|
||||
return session.Delete(bean)
|
||||
}
|
||||
|
||||
func (engine *Engine) Get(bean interface{}) error {
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return session.Get(bean)
|
||||
}
|
||||
|
||||
func (engine *Engine) Find(beans interface{}) error {
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return session.Find(beans)
|
||||
}
|
||||
|
||||
func (engine *Engine) Count(bean interface{}) (int64, error) {
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
return session.Count(bean)
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#!/usr/bin/env bash
|
||||
|
||||
if [ ! -f install ]; then
|
||||
echo 'install must be run within its container folder' 1>&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
CURDIR=`pwd`
|
||||
NEWPATH="$GOPATH/src/${PWD##*/}"
|
||||
if [ ! -d "$NEWPATH" ]; then
|
||||
ln -s $CURDIR $NEWPATH
|
||||
fi
|
||||
|
||||
gofmt -w $CURDIR
|
||||
|
||||
cd $NEWPATH
|
||||
go install ${PWD##*/}
|
||||
cd $CURDIR
|
||||
|
||||
echo 'finished'
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
package xorm
|
||||
|
||||
import (
|
||||
//"reflect"
|
||||
//"strings"
|
||||
)
|
||||
|
||||
type IMapper interface {
|
||||
Obj2Table(string) string
|
||||
Table2Obj(string) string
|
||||
}
|
||||
|
||||
type SnakeMapper struct {
|
||||
}
|
||||
|
||||
func snakeCasedName(name string) string {
|
||||
newstr := make([]rune, 0)
|
||||
firstTime := true
|
||||
|
||||
for _, chr := range name {
|
||||
if isUpper := 'A' <= chr && chr <= 'Z'; isUpper {
|
||||
if firstTime == true {
|
||||
firstTime = false
|
||||
} else {
|
||||
newstr = append(newstr, '_')
|
||||
}
|
||||
chr -= ('A' - 'a')
|
||||
}
|
||||
newstr = append(newstr, chr)
|
||||
}
|
||||
|
||||
return string(newstr)
|
||||
}
|
||||
|
||||
func Pascal2Sql(s string) (d string) {
|
||||
d = ""
|
||||
lastIdx := 0
|
||||
for i := 0; i < len(s); i++ {
|
||||
if s[i] >= 'A' && s[i] <= 'Z' {
|
||||
if lastIdx < i {
|
||||
d += s[lastIdx+1 : i]
|
||||
}
|
||||
if i != 0 {
|
||||
d += "_"
|
||||
}
|
||||
d += string(s[i] + 32)
|
||||
lastIdx = i
|
||||
}
|
||||
}
|
||||
d += s[lastIdx+1:]
|
||||
return
|
||||
}
|
||||
|
||||
func (mapper SnakeMapper) Obj2Table(name string) string {
|
||||
return snakeCasedName(name)
|
||||
}
|
||||
|
||||
func titleCasedName(name string) string {
|
||||
newstr := make([]rune, 0)
|
||||
upNextChar := true
|
||||
|
||||
for _, chr := range name {
|
||||
switch {
|
||||
case upNextChar:
|
||||
upNextChar = false
|
||||
chr -= ('a' - 'A')
|
||||
case chr == '_':
|
||||
upNextChar = true
|
||||
continue
|
||||
}
|
||||
|
||||
newstr = append(newstr, chr)
|
||||
}
|
||||
|
||||
return string(newstr)
|
||||
}
|
||||
|
||||
func (mapper SnakeMapper) Table2Obj(name string) string {
|
||||
return titleCasedName(name)
|
||||
}
|
||||
|
|
@ -0,0 +1,601 @@
|
|||
package xorm
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
func getTypeName(obj interface{}) (typestr string) {
|
||||
typ := reflect.TypeOf(obj)
|
||||
typestr = typ.String()
|
||||
|
||||
lastDotIndex := strings.LastIndex(typestr, ".")
|
||||
if lastDotIndex != -1 {
|
||||
typestr = typestr[lastDotIndex+1:]
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func StructName(s interface{}) string {
|
||||
v := reflect.TypeOf(s)
|
||||
return Type2StructName(v)
|
||||
}
|
||||
|
||||
func Type2StructName(v reflect.Type) string {
|
||||
for v.Kind() == reflect.Ptr {
|
||||
v = v.Elem()
|
||||
}
|
||||
return v.Name()
|
||||
}
|
||||
|
||||
type Session struct {
|
||||
Db *sql.DB
|
||||
Engine *Engine
|
||||
Statements []Statement
|
||||
Mapper IMapper
|
||||
AutoCommit bool
|
||||
ParamIteration int
|
||||
CurStatementIdx int
|
||||
}
|
||||
|
||||
func (session *Session) Init() {
|
||||
session.Statements = make([]Statement, 0)
|
||||
/*session.Statement.TableName = ""
|
||||
session.Statement.LimitStr = 0
|
||||
session.Statement.OffsetStr = 0
|
||||
session.Statement.WhereStr = ""
|
||||
session.Statement.ParamStr = make([]interface{}, 0)
|
||||
session.Statement.OrderStr = ""
|
||||
session.Statement.JoinStr = ""
|
||||
session.Statement.GroupByStr = ""
|
||||
session.Statement.HavingStr = ""*/
|
||||
session.CurStatementIdx = -1
|
||||
|
||||
session.ParamIteration = 1
|
||||
}
|
||||
|
||||
func (session *Session) Close() {
|
||||
defer session.Db.Close()
|
||||
}
|
||||
|
||||
func (session *Session) CurrentStatement() *Statement {
|
||||
if session.CurStatementIdx > -1 {
|
||||
return &session.Statements[session.CurStatementIdx]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (session *Session) AutoStatement() *Statement {
|
||||
if session.CurStatementIdx == -1 {
|
||||
session.newStatement()
|
||||
}
|
||||
return session.CurrentStatement()
|
||||
}
|
||||
|
||||
//Execute sql
|
||||
func (session *Session) Exec(finalQueryString string, args ...interface{}) (sql.Result, error) {
|
||||
rs, err := session.Db.Prepare(finalQueryString)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rs.Close()
|
||||
|
||||
res, err := rs.Exec(args...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return res, nil
|
||||
}
|
||||
|
||||
func (session *Session) Where(querystring interface{}, args ...interface{}) *Session {
|
||||
statement := session.AutoStatement()
|
||||
switch querystring := querystring.(type) {
|
||||
case string:
|
||||
statement.WhereStr = querystring
|
||||
case int:
|
||||
if session.Engine.Protocol == "pgsql" {
|
||||
statement.WhereStr = fmt.Sprintf("%v%v%v = $%v", session.Engine.QuoteIdentifier, statement.Table.PKColumn().Name, session.Engine.QuoteIdentifier, session.ParamIteration)
|
||||
} else {
|
||||
statement.WhereStr = fmt.Sprintf("%v%v%v = ?", session.Engine.QuoteIdentifier, statement.Table.PKColumn().Name, session.Engine.QuoteIdentifier)
|
||||
session.ParamIteration++
|
||||
}
|
||||
args = append(args, querystring)
|
||||
}
|
||||
statement.ParamStr = args
|
||||
return session
|
||||
}
|
||||
|
||||
func (session *Session) Limit(start int, size ...int) *Session {
|
||||
session.AutoStatement().LimitStr = start
|
||||
if len(size) > 0 {
|
||||
session.CurrentStatement().OffsetStr = size[0]
|
||||
}
|
||||
return session
|
||||
}
|
||||
|
||||
func (session *Session) Offset(offset int) *Session {
|
||||
session.AutoStatement().OffsetStr = offset
|
||||
return session
|
||||
}
|
||||
|
||||
func (session *Session) OrderBy(order string) *Session {
|
||||
session.AutoStatement().OrderStr = order
|
||||
return session
|
||||
}
|
||||
|
||||
//The join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
|
||||
func (session *Session) Join(join_operator, tablename, condition string) *Session {
|
||||
if session.AutoStatement().JoinStr != "" {
|
||||
session.CurrentStatement().JoinStr = session.CurrentStatement().JoinStr + fmt.Sprintf("%v JOIN %v ON %v", join_operator, tablename, condition)
|
||||
} else {
|
||||
session.CurrentStatement().JoinStr = fmt.Sprintf("%v JOIN %v ON %v", join_operator, tablename, condition)
|
||||
}
|
||||
|
||||
return session
|
||||
}
|
||||
|
||||
func (session *Session) GroupBy(keys string) *Session {
|
||||
session.AutoStatement().GroupByStr = fmt.Sprintf("GROUP BY %v", keys)
|
||||
return session
|
||||
}
|
||||
|
||||
func (session *Session) Having(conditions string) *Session {
|
||||
session.AutoStatement().HavingStr = fmt.Sprintf("HAVING %v", conditions)
|
||||
return session
|
||||
}
|
||||
|
||||
func (session *Session) Begin() {
|
||||
|
||||
}
|
||||
|
||||
func (session *Session) Rollback() {
|
||||
|
||||
}
|
||||
|
||||
func (session *Session) Commit() {
|
||||
for _, statement := range session.Statements {
|
||||
sql := statement.generateSql()
|
||||
session.Exec(sql)
|
||||
}
|
||||
}
|
||||
|
||||
func (session *Session) TableName(bean interface{}) string {
|
||||
return session.Mapper.Obj2Table(StructName(bean))
|
||||
}
|
||||
|
||||
func (session *Session) newStatement() {
|
||||
state := Statement{}
|
||||
state.Session = session
|
||||
session.Statements = append(session.Statements, state)
|
||||
session.CurStatementIdx = len(session.Statements) - 1
|
||||
}
|
||||
|
||||
func (session *Session) scanMapIntoStruct(obj interface{}, objMap map[string][]byte) error {
|
||||
dataStruct := reflect.Indirect(reflect.ValueOf(obj))
|
||||
if dataStruct.Kind() != reflect.Struct {
|
||||
return errors.New("expected a pointer to a struct")
|
||||
}
|
||||
|
||||
tablName := session.TableName(obj)
|
||||
table := session.Engine.Tables[tablName]
|
||||
|
||||
for key, data := range objMap {
|
||||
structField := dataStruct.FieldByName(table.Columns[key].FieldName)
|
||||
if !structField.CanSet() {
|
||||
continue
|
||||
}
|
||||
|
||||
var v interface{}
|
||||
|
||||
switch structField.Type().Kind() {
|
||||
case reflect.Slice:
|
||||
v = data
|
||||
case reflect.String:
|
||||
v = string(data)
|
||||
case reflect.Bool:
|
||||
v = string(data) == "1"
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32:
|
||||
x, err := strconv.Atoi(string(data))
|
||||
if err != nil {
|
||||
return errors.New("arg " + key + " as int: " + err.Error())
|
||||
}
|
||||
v = x
|
||||
case reflect.Int64:
|
||||
x, err := strconv.ParseInt(string(data), 10, 64)
|
||||
if err != nil {
|
||||
return errors.New("arg " + key + " as int: " + err.Error())
|
||||
}
|
||||
v = x
|
||||
case reflect.Float32, reflect.Float64:
|
||||
x, err := strconv.ParseFloat(string(data), 64)
|
||||
if err != nil {
|
||||
return errors.New("arg " + key + " as float64: " + err.Error())
|
||||
}
|
||||
v = x
|
||||
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
x, err := strconv.ParseUint(string(data), 10, 64)
|
||||
if err != nil {
|
||||
return errors.New("arg " + key + " as int: " + err.Error())
|
||||
}
|
||||
v = x
|
||||
//Now only support Time type
|
||||
case reflect.Struct:
|
||||
if structField.Type().String() != "time.Time" {
|
||||
return errors.New("unsupported struct type in Scan: " + structField.Type().String())
|
||||
}
|
||||
|
||||
x, err := time.Parse("2006-01-02 15:04:05", string(data))
|
||||
if err != nil {
|
||||
x, err = time.Parse("2006-01-02 15:04:05.000 -0700", string(data))
|
||||
|
||||
if err != nil {
|
||||
return errors.New("unsupported time format: " + string(data))
|
||||
}
|
||||
}
|
||||
|
||||
v = x
|
||||
default:
|
||||
return errors.New("unsupported type in Scan: " + reflect.TypeOf(v).String())
|
||||
}
|
||||
|
||||
structField.Set(reflect.ValueOf(v))
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (session *Session) Get(output interface{}) error {
|
||||
statement := session.AutoStatement()
|
||||
session.Limit(1)
|
||||
tableName := session.TableName(output)
|
||||
table := session.Engine.Tables[tableName]
|
||||
statement.Table = &table
|
||||
|
||||
resultsSlice, err := session.FindMap(statement)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(resultsSlice) == 0 {
|
||||
return nil
|
||||
} else if len(resultsSlice) == 1 {
|
||||
results := resultsSlice[0]
|
||||
err := session.scanMapIntoStruct(output, results)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
return errors.New("More than one record")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (session *Session) Count(bean interface{}) (int64, error) {
|
||||
statement := session.AutoStatement()
|
||||
session.Limit(1)
|
||||
tableName := session.TableName(bean)
|
||||
table := session.Engine.Tables[tableName]
|
||||
statement.Table = &table
|
||||
|
||||
resultsSlice, err := session.SQL2Map(statement.genCountSql(), statement.ParamStr)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
var total int64 = 0
|
||||
for _, results := range resultsSlice {
|
||||
total, err = strconv.ParseInt(string(results["total"]), 10, 64)
|
||||
break
|
||||
}
|
||||
|
||||
return int64(total), err
|
||||
}
|
||||
|
||||
func (session *Session) Find(rowsSlicePtr interface{}) error {
|
||||
statement := session.AutoStatement()
|
||||
|
||||
sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
|
||||
if sliceValue.Kind() != reflect.Slice {
|
||||
return errors.New("needs a pointer to a slice")
|
||||
}
|
||||
|
||||
sliceElementType := sliceValue.Type().Elem()
|
||||
|
||||
tableName := session.Mapper.Obj2Table(Type2StructName(sliceElementType))
|
||||
table := session.Engine.Tables[tableName]
|
||||
statement.Table = &table
|
||||
|
||||
resultsSlice, err := session.FindMap(statement)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, results := range resultsSlice {
|
||||
newValue := reflect.New(sliceElementType)
|
||||
err := session.scanMapIntoStruct(newValue.Interface(), results)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sliceValue.Set(reflect.Append(sliceValue, reflect.Indirect(reflect.ValueOf(newValue.Interface()))))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (session *Session) SQL2Map(sqls string, paramStr []interface{}) (resultsSlice []map[string][]byte, err error) {
|
||||
if session.Engine.ShowSQL {
|
||||
fmt.Println(sqls)
|
||||
}
|
||||
s, err := session.Db.Prepare(sqls)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer s.Close()
|
||||
res, err := s.Query(paramStr...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer res.Close()
|
||||
fields, err := res.Columns()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for res.Next() {
|
||||
result := make(map[string][]byte)
|
||||
var scanResultContainers []interface{}
|
||||
for i := 0; i < len(fields); i++ {
|
||||
var scanResultContainer interface{}
|
||||
scanResultContainers = append(scanResultContainers, &scanResultContainer)
|
||||
}
|
||||
if err := res.Scan(scanResultContainers...); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for ii, key := range fields {
|
||||
rawValue := reflect.Indirect(reflect.ValueOf(scanResultContainers[ii]))
|
||||
|
||||
//if row is null then ignore
|
||||
if rawValue.Interface() == nil {
|
||||
continue
|
||||
}
|
||||
aa := reflect.TypeOf(rawValue.Interface())
|
||||
vv := reflect.ValueOf(rawValue.Interface())
|
||||
var str string
|
||||
switch aa.Kind() {
|
||||
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
str = strconv.FormatInt(vv.Int(), 10)
|
||||
|
||||
result[key] = []byte(str)
|
||||
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
str = strconv.FormatUint(vv.Uint(), 10)
|
||||
result[key] = []byte(str)
|
||||
case reflect.Float32, reflect.Float64:
|
||||
str = strconv.FormatFloat(vv.Float(), 'f', -1, 64)
|
||||
result[key] = []byte(str)
|
||||
case reflect.Slice:
|
||||
if aa.Elem().Kind() == reflect.Uint8 {
|
||||
result[key] = rawValue.Interface().([]byte)
|
||||
break
|
||||
}
|
||||
case reflect.String:
|
||||
str = vv.String()
|
||||
result[key] = []byte(str)
|
||||
//时间类型
|
||||
case reflect.Struct:
|
||||
str = rawValue.Interface().(time.Time).Format("2006-01-02 15:04:05.000 -0700")
|
||||
result[key] = []byte(str)
|
||||
}
|
||||
|
||||
}
|
||||
resultsSlice = append(resultsSlice, result)
|
||||
}
|
||||
return resultsSlice, nil
|
||||
}
|
||||
|
||||
func (session *Session) FindMap(statement *Statement) (resultsSlice []map[string][]byte, err error) {
|
||||
sqls := statement.generateSql()
|
||||
return session.SQL2Map(sqls, statement.ParamStr)
|
||||
}
|
||||
|
||||
func (session *Session) Insert(beans ...interface{}) (int64, error) {
|
||||
var lastId int64 = -1
|
||||
for _, bean := range beans {
|
||||
lastId, err := session.InsertOne(bean)
|
||||
if err != nil {
|
||||
return lastId, err
|
||||
}
|
||||
}
|
||||
return lastId, nil
|
||||
}
|
||||
|
||||
func (session *Session) InsertOne(bean interface{}) (int64, error) {
|
||||
tableName := session.TableName(bean)
|
||||
table := session.Engine.Tables[tableName]
|
||||
|
||||
colNames := make([]string, 0)
|
||||
colPlaces := make([]string, 0)
|
||||
var args = make([]interface{}, 0)
|
||||
for _, col := range table.Columns {
|
||||
fieldValue := reflect.Indirect(reflect.ValueOf(bean)).FieldByName(col.FieldName)
|
||||
val := fieldValue.Interface()
|
||||
if col.AutoIncrement {
|
||||
if fieldValue.Int() == 0 {
|
||||
continue
|
||||
}
|
||||
}
|
||||
args = append(args, val)
|
||||
colNames = append(colNames, col.Name)
|
||||
colPlaces = append(colPlaces, "?")
|
||||
}
|
||||
|
||||
statement := fmt.Sprintf("INSERT INTO %v%v%v (%v) VALUES (%v)",
|
||||
session.Engine.QuoteIdentifier,
|
||||
tableName,
|
||||
session.Engine.QuoteIdentifier,
|
||||
strings.Join(colNames, ", "),
|
||||
strings.Join(colPlaces, ", "))
|
||||
|
||||
if session.Engine.ShowSQL {
|
||||
fmt.Println(statement)
|
||||
}
|
||||
|
||||
res, err := session.Exec(statement, args...)
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
|
||||
id, err := res.LastInsertId()
|
||||
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
func (session *Session) Update(bean interface{}) (int64, error) {
|
||||
tableName := session.TableName(bean)
|
||||
table := session.Engine.Tables[tableName]
|
||||
|
||||
colNames := make([]string, 0)
|
||||
var args = make([]interface{}, 0)
|
||||
for _, col := range table.Columns {
|
||||
if col.Name == "" {
|
||||
continue
|
||||
}
|
||||
fieldValue := reflect.Indirect(reflect.ValueOf(bean)).FieldByName(col.FieldName)
|
||||
fieldType := reflect.TypeOf(fieldValue.Interface())
|
||||
val := fieldValue.Interface()
|
||||
switch fieldType.Kind() {
|
||||
case reflect.String:
|
||||
if fieldValue.String() == "" {
|
||||
continue
|
||||
}
|
||||
case reflect.Int, reflect.Int32, reflect.Int64:
|
||||
if fieldValue.Int() == 0 {
|
||||
continue
|
||||
}
|
||||
case reflect.Struct:
|
||||
if fieldType == reflect.TypeOf(time.Now()) {
|
||||
t := fieldValue.Interface().(time.Time)
|
||||
if t.IsZero() {
|
||||
continue
|
||||
}
|
||||
}
|
||||
default:
|
||||
continue
|
||||
}
|
||||
args = append(args, val)
|
||||
colNames = append(colNames, session.Engine.QuoteIdentifier+col.Name+session.Engine.QuoteIdentifier+"=?")
|
||||
}
|
||||
|
||||
var condition = ""
|
||||
st := session.CurrentStatement()
|
||||
if st != nil && st.WhereStr != "" {
|
||||
condition = fmt.Sprintf("WHERE %v", st.WhereStr)
|
||||
}
|
||||
|
||||
if condition == "" {
|
||||
fieldValue := reflect.Indirect(reflect.ValueOf(bean)).FieldByName(table.PKColumn().FieldName)
|
||||
if fieldValue.Int() != 0 {
|
||||
condition = fmt.Sprintf("WHERE %v = ?", table.PKColumn().Name)
|
||||
args = append(args, fieldValue.Interface())
|
||||
}
|
||||
}
|
||||
|
||||
statement := fmt.Sprintf("UPDATE %v%v%v SET %v %v",
|
||||
session.Engine.QuoteIdentifier,
|
||||
tableName,
|
||||
session.Engine.QuoteIdentifier,
|
||||
strings.Join(colNames, ", "),
|
||||
condition)
|
||||
|
||||
if session.Engine.ShowSQL {
|
||||
fmt.Println(statement)
|
||||
}
|
||||
|
||||
res, err := session.Exec(statement, args...)
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
|
||||
id, err := res.RowsAffected()
|
||||
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
func (session *Session) Delete(bean interface{}) (int64, error) {
|
||||
tableName := session.TableName(bean)
|
||||
table := session.Engine.Tables[tableName]
|
||||
|
||||
colNames := make([]string, 0)
|
||||
var args = make([]interface{}, 0)
|
||||
for _, col := range table.Columns {
|
||||
if col.Name == "" {
|
||||
continue
|
||||
}
|
||||
fieldValue := reflect.Indirect(reflect.ValueOf(bean)).FieldByName(col.FieldName)
|
||||
fieldType := reflect.TypeOf(fieldValue.Interface())
|
||||
val := fieldValue.Interface()
|
||||
switch fieldType.Kind() {
|
||||
case reflect.String:
|
||||
if fieldValue.String() == "" {
|
||||
continue
|
||||
}
|
||||
case reflect.Int, reflect.Int32, reflect.Int64:
|
||||
if fieldValue.Int() == 0 {
|
||||
continue
|
||||
}
|
||||
case reflect.Struct:
|
||||
if fieldType == reflect.TypeOf(time.Now()) {
|
||||
t := fieldValue.Interface().(time.Time)
|
||||
if t.IsZero() {
|
||||
continue
|
||||
}
|
||||
}
|
||||
default:
|
||||
continue
|
||||
}
|
||||
args = append(args, val)
|
||||
colNames = append(colNames, session.Engine.QuoteIdentifier+col.Name+session.Engine.QuoteIdentifier+"=?")
|
||||
}
|
||||
|
||||
var condition = ""
|
||||
st := session.CurrentStatement()
|
||||
if st != nil && st.WhereStr != "" {
|
||||
condition = fmt.Sprintf("WHERE %v", st.WhereStr)
|
||||
if len(colNames) > 0 {
|
||||
condition += " and "
|
||||
condition += strings.Join(colNames, " and ")
|
||||
}
|
||||
} else {
|
||||
condition = "WHERE " + strings.Join(colNames, " and ")
|
||||
}
|
||||
|
||||
statement := fmt.Sprintf("DELETE FROM %v%v%v %v",
|
||||
session.Engine.QuoteIdentifier,
|
||||
tableName,
|
||||
session.Engine.QuoteIdentifier,
|
||||
condition)
|
||||
|
||||
if session.Engine.ShowSQL {
|
||||
fmt.Println(statement)
|
||||
}
|
||||
|
||||
res, err := session.Exec(statement, args...)
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
|
||||
id, err := res.RowsAffected()
|
||||
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
package xorm
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
type Statement struct {
|
||||
TableName string
|
||||
Table *Table
|
||||
Session *Session
|
||||
LimitStr int
|
||||
OffsetStr int
|
||||
WhereStr string
|
||||
ParamStr []interface{}
|
||||
OrderStr string
|
||||
JoinStr string
|
||||
GroupByStr string
|
||||
HavingStr string
|
||||
}
|
||||
|
||||
func (statement *Statement) Limit(start int, size ...int) *Statement {
|
||||
statement.LimitStr = start
|
||||
if len(size) > 0 {
|
||||
statement.OffsetStr = size[0]
|
||||
}
|
||||
return statement
|
||||
}
|
||||
|
||||
func (statement *Statement) Offset(offset int) *Statement {
|
||||
statement.OffsetStr = offset
|
||||
return statement
|
||||
}
|
||||
|
||||
func (statement *Statement) OrderBy(order string) *Statement {
|
||||
statement.OrderStr = order
|
||||
return statement
|
||||
}
|
||||
|
||||
func (statement *Statement) Select(colums string) *Statement {
|
||||
//statement.ColumnStr = colums
|
||||
return statement
|
||||
}
|
||||
|
||||
func (statement Statement) generateSql() string {
|
||||
columnStr := statement.Table.ColumnStr()
|
||||
return statement.genSelectSql(columnStr)
|
||||
}
|
||||
|
||||
func (statement Statement) genCountSql() string {
|
||||
return statement.genSelectSql("count(*) as total")
|
||||
}
|
||||
|
||||
func (statement Statement) genSelectSql(columnStr string) (a string) {
|
||||
session := statement.Session
|
||||
if session.Engine.Protocol == "mssql" {
|
||||
if statement.OffsetStr > 0 {
|
||||
a = fmt.Sprintf("select ROW_NUMBER() OVER(order by %v )as rownum,%v from %v",
|
||||
statement.Table.PKColumn().Name,
|
||||
columnStr,
|
||||
statement.Table.Name)
|
||||
if statement.WhereStr != "" {
|
||||
a = fmt.Sprintf("%v WHERE %v", a, statement.WhereStr)
|
||||
}
|
||||
a = fmt.Sprintf("select %v from (%v) "+
|
||||
"as a where rownum between %v and %v",
|
||||
columnStr,
|
||||
a,
|
||||
statement.OffsetStr,
|
||||
statement.LimitStr)
|
||||
} else if statement.LimitStr > 0 {
|
||||
a = fmt.Sprintf("SELECT top %v %v FROM %v", statement.LimitStr, columnStr, statement.Table.Name)
|
||||
if statement.WhereStr != "" {
|
||||
a = fmt.Sprintf("%v WHERE %v", a, statement.WhereStr)
|
||||
}
|
||||
if statement.GroupByStr != "" {
|
||||
a = fmt.Sprintf("%v %v", a, statement.GroupByStr)
|
||||
}
|
||||
if statement.HavingStr != "" {
|
||||
a = fmt.Sprintf("%v %v", a, statement.HavingStr)
|
||||
}
|
||||
if statement.OrderStr != "" {
|
||||
a = fmt.Sprintf("%v ORDER BY %v", a, statement.OrderStr)
|
||||
}
|
||||
} else {
|
||||
a = fmt.Sprintf("SELECT %v FROM %v", columnStr, statement.Table.Name)
|
||||
if statement.WhereStr != "" {
|
||||
a = fmt.Sprintf("%v WHERE %v", a, statement.WhereStr)
|
||||
}
|
||||
if statement.GroupByStr != "" {
|
||||
a = fmt.Sprintf("%v %v", a, statement.GroupByStr)
|
||||
}
|
||||
if statement.HavingStr != "" {
|
||||
a = fmt.Sprintf("%v %v", a, statement.HavingStr)
|
||||
}
|
||||
if statement.OrderStr != "" {
|
||||
a = fmt.Sprintf("%v ORDER BY %v", a, statement.OrderStr)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
a = fmt.Sprintf("SELECT %v FROM %v", columnStr, statement.Table.Name)
|
||||
if statement.JoinStr != "" {
|
||||
a = fmt.Sprintf("%v %v", a, statement.JoinStr)
|
||||
}
|
||||
if statement.WhereStr != "" {
|
||||
a = fmt.Sprintf("%v WHERE %v", a, statement.WhereStr)
|
||||
}
|
||||
if statement.GroupByStr != "" {
|
||||
a = fmt.Sprintf("%v %v", a, statement.GroupByStr)
|
||||
}
|
||||
if statement.HavingStr != "" {
|
||||
a = fmt.Sprintf("%v %v", a, statement.HavingStr)
|
||||
}
|
||||
if statement.OrderStr != "" {
|
||||
a = fmt.Sprintf("%v ORDER BY %v", a, statement.OrderStr)
|
||||
}
|
||||
if statement.OffsetStr > 0 {
|
||||
a = fmt.Sprintf("%v LIMIT %v, %v", a, statement.OffsetStr, statement.LimitStr)
|
||||
} else if statement.LimitStr > 0 {
|
||||
a = fmt.Sprintf("%v LIMIT %v", a, statement.LimitStr)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
/*func (statement *Statement) genInsertSQL() string {
|
||||
table = statement.Table
|
||||
colNames := make([]string, len(table.Columns))
|
||||
for idx, col := range table.Columns {
|
||||
if col.Name == "" {
|
||||
continue
|
||||
}
|
||||
colNames[idx] = col.Name
|
||||
}
|
||||
return strings.Join(colNames, ", ")
|
||||
|
||||
colNames := make([]string, len(table.Columns))
|
||||
for idx, col := range table.Columns {
|
||||
if col.Name == "" {
|
||||
continue
|
||||
}
|
||||
colNames[idx] = "?"
|
||||
}
|
||||
strings.Join(colNames, ", ")
|
||||
}*/
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
package xorm
|
||||
|
||||
import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
// 'sqlite:///foo.db'
|
||||
// 'sqlite:////Uses/lunny/foo.db'
|
||||
// 'sqlite:///:memory:'
|
||||
// '<protocol>://<username>:<passwd>@<host>/<dbname>?charset=<encoding>'
|
||||
func Create(schema string) Engine {
|
||||
engine := Engine{}
|
||||
engine.Mapper = SnakeMapper{}
|
||||
engine.Tables = make(map[string]Table)
|
||||
l := strings.Split(schema, "://")
|
||||
if len(l) == 2 {
|
||||
engine.Protocol = l[0]
|
||||
if l[0] == "sqlite" {
|
||||
engine.Charset = "utf8"
|
||||
engine.AutoIncrement = "AUTOINCREMENT"
|
||||
if l[1] == "/:memory:" {
|
||||
engine.Others = l[1]
|
||||
} else if strings.Index(l[1], "//") == 0 {
|
||||
engine.Others = l[1][1:]
|
||||
} else if strings.Index(l[1], "/") == 0 {
|
||||
engine.Others = "." + l[1]
|
||||
}
|
||||
} else {
|
||||
engine.AutoIncrement = "AUTO_INCREMENT"
|
||||
x := strings.Split(l[1], ":")
|
||||
engine.UserName = x[0]
|
||||
y := strings.Split(x[1], "@")
|
||||
engine.Password = y[0]
|
||||
z := strings.Split(y[1], "/")
|
||||
engine.Host = z[0]
|
||||
a := strings.Split(z[1], "?")
|
||||
engine.DBName = a[0]
|
||||
if len(a) == 2 {
|
||||
engine.Charset = strings.Split(a[1], "=")[1]
|
||||
} else {
|
||||
engine.Charset = "utf8"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return engine
|
||||
}
|
||||
|
|
@ -0,0 +1,190 @@
|
|||
package xorm_test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
_ "github.com/Go-SQL-Driver/MySQL"
|
||||
//_ "github.com/ziutek/mymysql/godrv"
|
||||
//_ "github.com/mattn/go-sqlite3"
|
||||
"testing"
|
||||
"time"
|
||||
"xorm"
|
||||
)
|
||||
|
||||
/*
|
||||
CREATE TABLE `userinfo` (
|
||||
`uid` INT(10) NULL AUTO_INCREMENT,
|
||||
`username` VARCHAR(64) NULL,
|
||||
`departname` VARCHAR(64) NULL,
|
||||
`created` DATE NULL,
|
||||
PRIMARY KEY (`uid`)
|
||||
);
|
||||
CREATE TABLE `userdeatail` (
|
||||
`uid` INT(10) NULL,
|
||||
`intro` TEXT NULL,
|
||||
`profile` TEXT NULL,
|
||||
PRIMARY KEY (`uid`)
|
||||
);
|
||||
*/
|
||||
|
||||
type Userinfo struct {
|
||||
Uid int `xorm:"id pk not null autoincr"`
|
||||
Username string
|
||||
Departname string
|
||||
Alias string `xorm:"-"`
|
||||
Created time.Time
|
||||
}
|
||||
|
||||
var engine xorm.Engine
|
||||
|
||||
func TestCreateEngine(t *testing.T) {
|
||||
engine = xorm.Create("mysql://root:123@localhost/test")
|
||||
//engine = orm.Create("mymysql://root:123@localhost/test")
|
||||
//engine = orm.Create("sqlite:///test.db")
|
||||
engine.ShowSQL = true
|
||||
}
|
||||
|
||||
func TestDirectCreateTable(t *testing.T) {
|
||||
err := engine.CreateTables(&Userinfo{})
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMapper(t *testing.T) {
|
||||
err := engine.UnMap(&Userinfo{})
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
err = engine.Map(&Userinfo{})
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
err = engine.DropAll()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
||||
err = engine.CreateAll()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsert(t *testing.T) {
|
||||
user := Userinfo{1, "xiaolunwen", "dev", "lunny", time.Now()}
|
||||
_, err := engine.Insert(&user)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsertAutoIncr(t *testing.T) {
|
||||
// auto increment insert
|
||||
user := Userinfo{Username: "xiaolunwen", Departname: "dev", Alias: "lunny", Created: time.Now()}
|
||||
_, err := engine.Insert(&user)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsertMulti(t *testing.T) {
|
||||
user1 := Userinfo{Username: "xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()}
|
||||
user2 := Userinfo{Username: "xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()}
|
||||
_, err := engine.Insert(&user1, &user2)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUpdate(t *testing.T) {
|
||||
// update by id
|
||||
user := Userinfo{Uid: 1, Username: "xxx"}
|
||||
_, err := engine.Update(&user)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDelete(t *testing.T) {
|
||||
user := Userinfo{Uid: 1}
|
||||
_, err := engine.Delete(&user)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGet(t *testing.T) {
|
||||
user := Userinfo{Uid: 2}
|
||||
|
||||
err := engine.Get(&user)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
fmt.Println(user)
|
||||
}
|
||||
|
||||
func TestFind(t *testing.T) {
|
||||
users := make([]Userinfo, 0)
|
||||
|
||||
err := engine.Find(&users)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
fmt.Println(users)
|
||||
}
|
||||
|
||||
func TestCount(t *testing.T) {
|
||||
user := Userinfo{}
|
||||
total, err := engine.Count(&user)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
fmt.Printf("Total %d records!!!", total)
|
||||
}
|
||||
|
||||
func TestWhere(t *testing.T) {
|
||||
users := make([]Userinfo, 0)
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
err = session.Where("id > ?", 2).Find(&users)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
fmt.Println(users)
|
||||
}
|
||||
|
||||
func TestLimit(t *testing.T) {
|
||||
users := make([]Userinfo, 0)
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
err = session.Limit(2, 1).Find(&users)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
fmt.Println(users)
|
||||
}
|
||||
|
||||
func TestOrder(t *testing.T) {
|
||||
users := make([]Userinfo, 0)
|
||||
session, err := engine.MakeSession()
|
||||
defer session.Close()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
err = session.OrderBy("id desc").Find(&users)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
fmt.Println(users)
|
||||
}
|
||||
|
||||
func TestTransaction(*testing.T) {
|
||||
}
|
||||
Loading…
Reference in New Issue