From 56029ace6f1a25608f54b3b6aaf1423006251b9f Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sat, 10 Jul 2021 17:05:12 +0800 Subject: [PATCH 01/10] Fix bug on dumptable --- engine.go | 134 ++++++++++++++++++------------------ integrations/engine_test.go | 9 +++ 2 files changed, 75 insertions(+), 68 deletions(-) diff --git a/engine.go b/engine.go index a45771a2..126b3e37 100644 --- a/engine.go +++ b/engine.go @@ -451,12 +451,45 @@ func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d return "NULL" } - if dq, ok := d.(bool); ok && (dstDialect.URI().DBType == schemas.SQLITE || - dstDialect.URI().DBType == schemas.MSSQL) { - if dq { - return "1" + switch t := d.(type) { + case *sql.NullInt64: + if t.Valid { + return fmt.Sprintf("%d", t.Int64) + } + return "NULL" + case *sql.NullTime: + if t.Valid { + return fmt.Sprintf("'%s'", t.Time.Format("2006-1-02 15:04:05")) + } + return "NULL" + case *sql.NullString: + if t.Valid { + return "'" + strings.Replace(t.String, "'", "''", -1) + "'" + } + return "NULL" + case *sql.NullInt32: + if t.Valid { + return fmt.Sprintf("%d", t.Int32) + } + return "NULL" + case *sql.NullFloat64: + if t.Valid { + return fmt.Sprintf("%f", t.Float64) + } + return "NULL" + case *sql.NullBool: + if t.Valid { + return strconv.FormatBool(t.Bool) + } + return "NULL" + case bool: + if dstDialect.URI().DBType == schemas.SQLITE || + dstDialect.URI().DBType == schemas.MSSQL { + if t { + return "1" + } + return "0" } - return "0" } if col.SQLType.IsText() { @@ -487,7 +520,7 @@ func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d return "'" + strings.Replace(v, "'", "''", -1) + "'" } else if col.SQLType.IsBlob() { if reflect.TypeOf(d).Kind() == reflect.Slice { - return fmt.Sprintf("%s", dstDialect.FormatBytes(d.([]byte))) + return dstDialect.FormatBytes(d.([]byte)) } else if reflect.TypeOf(d).Kind() == reflect.String { return fmt.Sprintf("'%s'", d.(string)) } @@ -497,7 +530,7 @@ func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d if col.SQLType.Name == schemas.Bool { return fmt.Sprintf("%v", strconv.FormatBool(d.([]byte)[0] != byte('0'))) } - return fmt.Sprintf("%s", string(d.([]byte))) + return string(d.([]byte)) case reflect.Int16, reflect.Int8, reflect.Int32, reflect.Int64, reflect.Int: if col.SQLType.Name == schemas.Bool { v := reflect.ValueOf(d).Int() > 0 @@ -609,6 +642,7 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch cols := table.ColumnsSeq() dstCols := dstTable.ColumnsSeq() + dstColumns := dstTable.Columns() colNames := engine.dialect.Quoter().Join(cols, ", ") destColNames := dstDialect.Quoter().Join(dstCols, ", ") @@ -619,73 +653,37 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch } defer rows.Close() - if table.Type != nil { - sess := engine.NewSession() - defer sess.Close() - for rows.Next() { - beanValue := reflect.New(table.Type) - bean := beanValue.Interface() - fields, err := rows.Columns() - if err != nil { - return err - } - scanResults, err := sess.row2Slice(rows, fields, bean) - if err != nil { - return err - } + types, err := rows.ColumnTypes() + if err != nil { + return err + } - dataStruct := utils.ReflectValue(bean) - _, err = sess.slice2Bean(scanResults, fields, bean, &dataStruct, table) - if err != nil { + sess := engine.NewSession() + defer sess.Close() + for rows.Next() { + _, err = io.WriteString(w, "INSERT INTO "+dstDialect.Quoter().Quote(dstTableName)+" ("+destColNames+") VALUES (") + if err != nil { + return err + } + + scanResults, err := sess.engine.scanInterfaces(rows, types) + if err != nil { + return err + } + for i, scanResult := range scanResults { + s := formatColumnValue(engine.DatabaseTZ, dstDialect, scanResult, dstColumns[i]) + if _, err = io.WriteString(w, s); err != nil { return err } - - _, err = io.WriteString(w, "INSERT INTO "+dstDialect.Quoter().Quote(dstTableName)+" ("+destColNames+") VALUES (") - if err != nil { - return err - } - - var temp string - for _, d := range dstCols { - col := table.GetColumn(d) - if col == nil { - return errors.New("unknown column error") + if i < len(scanResults)-1 { + if _, err = io.WriteString(w, ","); err != nil { + return err } - - field := dataStruct.FieldByIndex(col.FieldIndex) - temp += "," + formatColumnValue(engine.DatabaseTZ, dstDialect, field.Interface(), col) - } - _, err = io.WriteString(w, temp[1:]+");\n") - if err != nil { - return err } } - } else { - for rows.Next() { - dest := make([]interface{}, len(cols)) - err = rows.ScanSlice(&dest) - if err != nil { - return err - } - - _, err = io.WriteString(w, "INSERT INTO "+dstDialect.Quoter().Quote(dstTableName)+" ("+destColNames+") VALUES (") - if err != nil { - return err - } - - var temp string - for i, d := range dest { - col := table.GetColumn(cols[i]) - if col == nil { - return errors.New("unknow column error") - } - - temp += "," + formatColumnValue(engine.DatabaseTZ, dstDialect, d, col) - } - _, err = io.WriteString(w, temp[1:]+");\n") - if err != nil { - return err - } + _, err = io.WriteString(w, ");\n") + if err != nil { + return err } } diff --git a/integrations/engine_test.go b/integrations/engine_test.go index a06d91aa..48082ce5 100644 --- a/integrations/engine_test.go +++ b/integrations/engine_test.go @@ -172,8 +172,17 @@ func TestDumpTables(t *testing.T) { name := fmt.Sprintf("dump_%v-table.sql", tp) t.Run(name, func(t *testing.T) { assert.NoError(t, testEngine.(*xorm.Engine).DumpTablesToFile([]*schemas.Table{tb}, name, tp)) + }) } + + assert.NoError(t, testEngine.DropTables(new(TestDumpTableStruct))) + + importPath := fmt.Sprintf("dump_%v-table.sql", testEngine.Dialect().URI().DBType) + t.Run("import_"+importPath, func(t *testing.T) { + _, err = testEngine.ImportFile(importPath) + assert.NoError(t, err) + }) } func TestDumpTables2(t *testing.T) { -- 2.40.1 From e6a55d83b4d15210dfd1f3d7712703669fb1285f Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sat, 10 Jul 2021 17:34:02 +0800 Subject: [PATCH 02/10] remove unused code --- engine.go | 108 +++++++++++------------------------------------------- 1 file changed, 21 insertions(+), 87 deletions(-) diff --git a/engine.go b/engine.go index 126b3e37..9bcd0ea5 100644 --- a/engine.go +++ b/engine.go @@ -21,7 +21,6 @@ import ( "xorm.io/xorm/contexts" "xorm.io/xorm/core" "xorm.io/xorm/dialects" - "xorm.io/xorm/internal/json" "xorm.io/xorm/internal/utils" "xorm.io/xorm/log" "xorm.io/xorm/names" @@ -446,6 +445,17 @@ func (engine *Engine) DumpTables(tables []*schemas.Table, w io.Writer, tp ...sch return engine.dumpTables(tables, w, tp...) } +func formatBool(dialect dialects.Dialect, b bool) string { + if dialect.URI().DBType == schemas.SQLITE || + dialect.URI().DBType == schemas.MSSQL { + if b { + return "1" + } + return "0" + } + return strconv.FormatBool(b) +} + func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d interface{}, col *schemas.Column) string { if d == nil { return "NULL" @@ -459,7 +469,7 @@ func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d return "NULL" case *sql.NullTime: if t.Valid { - return fmt.Sprintf("'%s'", t.Time.Format("2006-1-02 15:04:05")) + return fmt.Sprintf("'%s'", t.Time.In(dbLocation).Format("2006-1-02 15:04:05")) } return "NULL" case *sql.NullString: @@ -479,95 +489,19 @@ func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d return "NULL" case *sql.NullBool: if t.Valid { - return strconv.FormatBool(t.Bool) + return formatBool(dstDialect, t.Bool) + } + return "NULL" + case *sql.RawBytes: + if t != nil { + return string([]byte(*t)) } return "NULL" case bool: - if dstDialect.URI().DBType == schemas.SQLITE || - dstDialect.URI().DBType == schemas.MSSQL { - if t { - return "1" - } - return "0" - } + return formatBool(dstDialect, t) } - if col.SQLType.IsText() { - var v string - switch reflect.TypeOf(d).Kind() { - case reflect.Struct, reflect.Array, reflect.Slice, reflect.Map: - bytes, err := json.DefaultJSONHandler.Marshal(d) - if err != nil { - v = fmt.Sprintf("%s", d) - } else { - v = string(bytes) - } - default: - v = fmt.Sprintf("%s", d) - } - - return "'" + strings.Replace(v, "'", "''", -1) + "'" - } else if col.SQLType.IsTime() { - if t, ok := d.(time.Time); ok { - return "'" + t.In(dbLocation).Format("2006-01-02 15:04:05") + "'" - } - var v = fmt.Sprintf("%s", d) - if strings.HasSuffix(v, " +0000 UTC") { - return fmt.Sprintf("'%s'", v[0:len(v)-len(" +0000 UTC")]) - } else if strings.HasSuffix(v, " +0000 +0000") { - return fmt.Sprintf("'%s'", v[0:len(v)-len(" +0000 +0000")]) - } - return "'" + strings.Replace(v, "'", "''", -1) + "'" - } else if col.SQLType.IsBlob() { - if reflect.TypeOf(d).Kind() == reflect.Slice { - return dstDialect.FormatBytes(d.([]byte)) - } else if reflect.TypeOf(d).Kind() == reflect.String { - return fmt.Sprintf("'%s'", d.(string)) - } - } else if col.SQLType.IsNumeric() { - switch reflect.TypeOf(d).Kind() { - case reflect.Slice: - if col.SQLType.Name == schemas.Bool { - return fmt.Sprintf("%v", strconv.FormatBool(d.([]byte)[0] != byte('0'))) - } - return string(d.([]byte)) - case reflect.Int16, reflect.Int8, reflect.Int32, reflect.Int64, reflect.Int: - if col.SQLType.Name == schemas.Bool { - v := reflect.ValueOf(d).Int() > 0 - if dstDialect.URI().DBType == schemas.SQLITE { - if v { - return "1" - } - return "0" - } - return fmt.Sprintf("%v", strconv.FormatBool(v)) - } - return fmt.Sprintf("%d", d) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - if col.SQLType.Name == schemas.Bool { - v := reflect.ValueOf(d).Uint() > 0 - if dstDialect.URI().DBType == schemas.SQLITE { - if v { - return "1" - } - return "0" - } - return fmt.Sprintf("%v", strconv.FormatBool(v)) - } - return fmt.Sprintf("%d", d) - default: - return fmt.Sprintf("%v", d) - } - } - - s := fmt.Sprintf("%v", d) - if strings.Contains(s, ":") || strings.Contains(s, "-") { - if strings.HasSuffix(s, " +0000 UTC") { - return fmt.Sprintf("'%s'", s[0:len(s)-len(" +0000 UTC")]) - } - return fmt.Sprintf("'%s'", s) - } - return s + return fmt.Sprintf("%v", d) } // dumpTables dump database all table structs and data to w with specify db type @@ -578,7 +512,7 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch } else { dstDialect = dialects.QueryDialect(tp[0]) if dstDialect == nil { - return errors.New("Unsupported database type") + return fmt.Errorf("unsupported database type %v", tp[0]) } uri := engine.dialect.URI() -- 2.40.1 From dcf63e09caa0d845ffdc6343bbc0254acd913be2 Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sat, 10 Jul 2021 18:25:59 +0800 Subject: [PATCH 03/10] Fix time --- convert/time.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/convert/time.go b/convert/time.go index 8901279b..9a2ed6e9 100644 --- a/convert/time.go +++ b/convert/time.go @@ -25,6 +25,13 @@ func String2Time(s string, originalLocation *time.Location, convertedLocation *t } dt = dt.In(convertedLocation) return &dt, nil + } else if len(s) == 25 && s[10] == 'T' && s[19] == '+' && s[22] == ':' { + dt, err := time.Parse("2006-01-02T15:04:05+07:00", s) + if err != nil { + return nil, err + } + dt = dt.In(convertedLocation) + return &dt, nil } return nil, fmt.Errorf("unsupported convertion from %s to time", s) } -- 2.40.1 From 09835b5673f3699282b64daaac3a44d7c180e65c Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sat, 10 Jul 2021 23:40:33 +0800 Subject: [PATCH 04/10] improve code --- convert.go | 1 - engine.go | 29 ++++++++++++++++++++++++----- 2 files changed, 24 insertions(+), 6 deletions(-) diff --git a/convert.go b/convert.go index 20a6e373..69277734 100644 --- a/convert.go +++ b/convert.go @@ -348,7 +348,6 @@ func convertAssign(dest, src interface{}, originalLocation *time.Location, conve *d = cloneBytes(s) return nil } - case time.Time: switch d := dest.(type) { case *string: diff --git a/engine.go b/engine.go index 9bcd0ea5..5ac9f13a 100644 --- a/engine.go +++ b/engine.go @@ -576,7 +576,6 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch cols := table.ColumnsSeq() dstCols := dstTable.ColumnsSeq() - dstColumns := dstTable.Columns() colNames := engine.dialect.Quoter().Join(cols, ", ") destColNames := dstDialect.Quoter().Join(dstCols, ", ") @@ -600,14 +599,34 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch return err } - scanResults, err := sess.engine.scanInterfaces(rows, types) + scanResults, err := sess.engine.scanStringInterface(rows, types) if err != nil { return err } for i, scanResult := range scanResults { - s := formatColumnValue(engine.DatabaseTZ, dstDialect, scanResult, dstColumns[i]) - if _, err = io.WriteString(w, s); err != nil { - return err + stp := schemas.SQLType{Name: types[i].DatabaseTypeName()} + if stp.IsNumeric() { + s := scanResult.(*sql.NullString) + if s.Valid { + if _, err = io.WriteString(w, s.String); err != nil { + return err + } + } else { + if _, err = io.WriteString(w, "NULL"); err != nil { + return err + } + } + } else { + s := scanResult.(*sql.NullString) + if s.Valid { + if _, err = io.WriteString(w, "'"+strings.ReplaceAll(s.String, "'", "''")+"'"); err != nil { + return err + } + } else { + if _, err = io.WriteString(w, "NULL"); err != nil { + return err + } + } } if i < len(scanResults)-1 { if _, err = io.WriteString(w, ","); err != nil { -- 2.40.1 From a320eff05f3ed043b730b88fd0a8ffd1e9cedade Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sat, 10 Jul 2021 23:47:30 +0800 Subject: [PATCH 05/10] remove unused functions --- engine.go | 60 ------------------------------------------------------- 1 file changed, 60 deletions(-) diff --git a/engine.go b/engine.go index 5ac9f13a..c79c0c14 100644 --- a/engine.go +++ b/engine.go @@ -13,7 +13,6 @@ import ( "os" "reflect" "runtime" - "strconv" "strings" "time" @@ -445,65 +444,6 @@ func (engine *Engine) DumpTables(tables []*schemas.Table, w io.Writer, tp ...sch return engine.dumpTables(tables, w, tp...) } -func formatBool(dialect dialects.Dialect, b bool) string { - if dialect.URI().DBType == schemas.SQLITE || - dialect.URI().DBType == schemas.MSSQL { - if b { - return "1" - } - return "0" - } - return strconv.FormatBool(b) -} - -func formatColumnValue(dbLocation *time.Location, dstDialect dialects.Dialect, d interface{}, col *schemas.Column) string { - if d == nil { - return "NULL" - } - - switch t := d.(type) { - case *sql.NullInt64: - if t.Valid { - return fmt.Sprintf("%d", t.Int64) - } - return "NULL" - case *sql.NullTime: - if t.Valid { - return fmt.Sprintf("'%s'", t.Time.In(dbLocation).Format("2006-1-02 15:04:05")) - } - return "NULL" - case *sql.NullString: - if t.Valid { - return "'" + strings.Replace(t.String, "'", "''", -1) + "'" - } - return "NULL" - case *sql.NullInt32: - if t.Valid { - return fmt.Sprintf("%d", t.Int32) - } - return "NULL" - case *sql.NullFloat64: - if t.Valid { - return fmt.Sprintf("%f", t.Float64) - } - return "NULL" - case *sql.NullBool: - if t.Valid { - return formatBool(dstDialect, t.Bool) - } - return "NULL" - case *sql.RawBytes: - if t != nil { - return string([]byte(*t)) - } - return "NULL" - case bool: - return formatBool(dstDialect, t) - } - - return fmt.Sprintf("%v", d) -} - // dumpTables dump database all table structs and data to w with specify db type func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...schemas.DBType) error { var dstDialect dialects.Dialect -- 2.40.1 From 2287b1429f28f85cf08a9c4ecfac1e576ccf7372 Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sun, 11 Jul 2021 10:23:27 +0800 Subject: [PATCH 06/10] Fix string2time --- convert/time.go | 4 ++-- convert/time_test.go | 27 +++++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 2 deletions(-) create mode 100644 convert/time_test.go diff --git a/convert/time.go b/convert/time.go index 9a2ed6e9..696b301c 100644 --- a/convert/time.go +++ b/convert/time.go @@ -19,14 +19,14 @@ func String2Time(s string, originalLocation *time.Location, convertedLocation *t dt = dt.In(convertedLocation) return &dt, nil } else if len(s) == 20 && s[10] == 'T' && s[19] == 'Z' { - dt, err := time.ParseInLocation("2006-01-02T15:04:05Z", s, originalLocation) + dt, err := time.ParseInLocation(time.RFC3339, s, originalLocation) if err != nil { return nil, err } dt = dt.In(convertedLocation) return &dt, nil } else if len(s) == 25 && s[10] == 'T' && s[19] == '+' && s[22] == ':' { - dt, err := time.Parse("2006-01-02T15:04:05+07:00", s) + dt, err := time.Parse(time.RFC3339, s) if err != nil { return nil, err } diff --git a/convert/time_test.go b/convert/time_test.go new file mode 100644 index 00000000..96089376 --- /dev/null +++ b/convert/time_test.go @@ -0,0 +1,27 @@ +// Copyright 2021 The Xorm Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package convert + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestString2Time(t *testing.T) { + var kases = map[string]time.Time{ + "2021-06-06T22:58:20+08:00": time.Date(2021, 6, 6, 22, 58, 20, 0, time.Local), + "2021-07-11 10:44:00": time.Date(2021, 7, 11, 18, 44, 0, 0, time.Local), + "2021-08-10T10:33:04Z": time.Date(2021, 8, 10, 18, 33, 04, 0, time.Local), + } + for layout, tm := range kases { + t.Run(layout, func(t *testing.T) { + target, err := String2Time(layout, time.UTC, time.Local) + assert.NoError(t, err) + assert.EqualValues(t, tm, *target) + }) + } +} -- 2.40.1 From b054008598ab7751fe6ff55afef668ae09bb292f Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sun, 11 Jul 2021 10:47:02 +0800 Subject: [PATCH 07/10] Fix test --- convert/time_test.go | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/convert/time_test.go b/convert/time_test.go index 96089376..ef01b362 100644 --- a/convert/time_test.go +++ b/convert/time_test.go @@ -12,14 +12,17 @@ import ( ) func TestString2Time(t *testing.T) { + expectedLoc, err := time.LoadLocation("Asia/Shanghai") + assert.NoError(t, err) + var kases = map[string]time.Time{ - "2021-06-06T22:58:20+08:00": time.Date(2021, 6, 6, 22, 58, 20, 0, time.Local), - "2021-07-11 10:44:00": time.Date(2021, 7, 11, 18, 44, 0, 0, time.Local), - "2021-08-10T10:33:04Z": time.Date(2021, 8, 10, 18, 33, 04, 0, time.Local), + "2021-06-06T22:58:20+08:00": time.Date(2021, 6, 6, 22, 58, 20, 0, expectedLoc), + "2021-07-11 10:44:00": time.Date(2021, 7, 11, 18, 44, 0, 0, expectedLoc), + "2021-08-10T10:33:04Z": time.Date(2021, 8, 10, 18, 33, 04, 0, expectedLoc), } for layout, tm := range kases { t.Run(layout, func(t *testing.T) { - target, err := String2Time(layout, time.UTC, time.Local) + target, err := String2Time(layout, time.UTC, expectedLoc) assert.NoError(t, err) assert.EqualValues(t, tm, *target) }) -- 2.40.1 From 0004399bbf9dcc8af426473d710add7fad9fb64a Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sun, 11 Jul 2021 15:08:50 +0800 Subject: [PATCH 08/10] Fix mssql test --- engine.go | 23 +++++++++++++++++++++++ schemas/type.go | 8 +++++++- 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/engine.go b/engine.go index c79c0c14..ee7606f5 100644 --- a/engine.go +++ b/engine.go @@ -444,6 +444,18 @@ func (engine *Engine) DumpTables(tables []*schemas.Table, w io.Writer, tp ...sch return engine.dumpTables(tables, w, tp...) } +func formatBool(s string, dstDialect dialects.Dialect) string { + if dstDialect.URI().DBType == schemas.MSSQL { + switch s { + case "true": + return "1" + case "false": + return "0" + } + } + return s +} + // dumpTables dump database all table structs and data to w with specify db type func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...schemas.DBType) error { var dstDialect dialects.Dialect @@ -556,6 +568,17 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch return err } } + } else if stp.IsBool() { + s := scanResult.(*sql.NullString) + if s.Valid { + if _, err = io.WriteString(w, formatBool(s.String, dstDialect)); err != nil { + return err + } + } else { + if _, err = io.WriteString(w, "NULL"); err != nil { + return err + } + } } else { s := scanResult.(*sql.NullString) if s.Valid { diff --git a/schemas/type.go b/schemas/type.go index f49348be..62e66c2e 100644 --- a/schemas/type.go +++ b/schemas/type.go @@ -39,6 +39,7 @@ const ( TIME_TYPE NUMERIC_TYPE ARRAY_TYPE + BOOL_TYPE ) // IsType reutrns ture if the column type is the same as the parameter @@ -64,6 +65,10 @@ func (s *SQLType) IsTime() bool { return s.IsType(TIME_TYPE) } +func (s *SQLType) IsBool() bool { + return s.IsType(BOOL_TYPE) +} + // IsNumeric returns true if column is a numeric type func (s *SQLType) IsNumeric() bool { return s.IsType(NUMERIC_TYPE) @@ -209,7 +214,8 @@ var ( Bytea: BLOB_TYPE, UniqueIdentifier: BLOB_TYPE, - Bool: NUMERIC_TYPE, + Bool: BOOL_TYPE, + Boolean: BOOL_TYPE, Serial: NUMERIC_TYPE, BigSerial: NUMERIC_TYPE, -- 2.40.1 From 3460c0fd040c08fdb3bd67337d659e5cea0e4774 Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sun, 11 Jul 2021 16:12:31 +0800 Subject: [PATCH 09/10] Fix mssql --- engine.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine.go b/engine.go index ee7606f5..d3ee8a8c 100644 --- a/engine.go +++ b/engine.go @@ -560,7 +560,7 @@ func (engine *Engine) dumpTables(tables []*schemas.Table, w io.Writer, tp ...sch if stp.IsNumeric() { s := scanResult.(*sql.NullString) if s.Valid { - if _, err = io.WriteString(w, s.String); err != nil { + if _, err = io.WriteString(w, formatBool(s.String, dstDialect)); err != nil { return err } } else { -- 2.40.1 From 0e2b646390c42013112ee8dff8a8e31bcb8b35da Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sun, 11 Jul 2021 19:27:37 +0800 Subject: [PATCH 10/10] Fix test --- integrations/engine_test.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/integrations/engine_test.go b/integrations/engine_test.go index 48082ce5..a594ee46 100644 --- a/integrations/engine_test.go +++ b/integrations/engine_test.go @@ -180,8 +180,12 @@ func TestDumpTables(t *testing.T) { importPath := fmt.Sprintf("dump_%v-table.sql", testEngine.Dialect().URI().DBType) t.Run("import_"+importPath, func(t *testing.T) { - _, err = testEngine.ImportFile(importPath) + sess := testEngine.NewSession() + defer sess.Close() + assert.NoError(t, sess.Begin()) + _, err = sess.ImportFile(importPath) assert.NoError(t, err) + assert.NoError(t, sess.Commit()) }) } -- 2.40.1