Browse Source

初始化

master
viviman 4 years ago
parent
commit
b86555d2eb
  1. 60
      golang_frame/go_to_gin/go_to_band_data/main.go
  2. 5
      golang_frame/go_to_gin/go_to_download/main.go
  3. 46
      golang_frame/go_to_gin/go_to_group_router/main.go
  4. 34
      golang_frame/go_to_gin/go_to_hello/main.go
  5. 56
      golang_frame/go_to_gin/go_to_http_handle/main.go
  6. 33
      golang_frame/go_to_gin/go_to_middleware/main.go
  7. 56
      golang_frame/go_to_gin/go_to_resp_formate/main.go
  8. 5
      golang_frame/go_to_gorilla_mux/go_to_hello/main.go
  9. 30
      golang_frame/go_to_iris/go_to_band_data/main.go
  10. 5
      golang_frame/go_to_iris/go_to_download/main.go
  11. 12
      golang_frame/go_to_iris/go_to_hello/main.go
  12. 5
      golang_frame/go_to_iris/go_to_resp_formate/main.go
  13. 5
      golang_frame/go_to_muxie/go_to_hello/main.go
  14. 52
      golang_learn/data_func/go_to_base64/main.go
  15. 15
      golang_learn/data_func/go_to_cmd/main.go
  16. 25
      golang_learn/data_func/go_to_copy_a57/main.go
  17. 49
      golang_learn/data_func/go_to_dir/writeDir/main.go
  18. 35
      golang_learn/data_func/go_to_file_path/go/main.go
  19. 37
      golang_learn/data_func/go_to_flag/demo01/main.go
  20. 20
      golang_learn/data_func/go_to_fyne/demo1/main.go
  21. 89
      golang_learn/data_func/go_to_fyne/demo2/main.go
  22. 3
      golang_learn/data_func/go_to_godotenv/main.env
  23. 21
      golang_learn/data_func/go_to_icon/main.exe.manifest
  24. 56
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_N03.go
  25. 53
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_N04.go
  26. 49
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_N05.go
  27. 42
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_P01.go
  28. 61
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_P02.go
  29. 61
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_P03.go
  30. 52
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q01.go
  31. 62
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q09.go
  32. 63
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q10.go
  33. 62
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q11.go
  34. 52
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q12.go
  35. 63
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q13.go
  36. 42
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S01.go
  37. 71
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S02.go
  38. 67
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S03.go
  39. 71
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S04.go
  40. 71
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S05.go
  41. 52
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S06.go
  42. 71
      golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S07.go

60
golang_frame/go_to_gin/go_to_band_data/main.go

@ -0,0 +1,60 @@
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
type Student struct {
Name string `form:"name"`
Classes string `form:"classes"`
/**
注意
该部分参数类别
若前端传递为 18则后端使用 int 类型
若前端传递为 "18"则后端使用 string 类型
*/
}
func main() {
engine := gin.Default()
// 1、http://127.0.0.1:8080/getHello?name=zhangsan&classes=软件工程
// 【区别】注意:GET请求使用 ShouldBindQuery
engine.GET("/getHello", func(context *gin.Context) {
var s Student
err := context.ShouldBindQuery(&s)
if err != nil {
panic(err.Error())
}
context.String(http.StatusOK, "姓名:"+s.Name+",班级:"+s.Classes)
})
// 2、http://127.0.0.1:8080/postHello
// 【区别】注意:【类GET】POST请求使用 ShouldBind
engine.POST("/postHello", func(context *gin.Context) {
var s Student
err := context.ShouldBind(&s)
if err != nil {
panic(err.Error())
}
context.String(http.StatusOK, "姓名:"+s.Name+",班级:"+s.Classes)
})
// 3、http://127.0.0.1:8080/jsonHello
// 【区别】注意:【JSON】POST请求使用 BindJSON
engine.POST("/jsonHello", func(context *gin.Context) {
var s Student
err := context.BindJSON(&s)
if err != nil {
panic(err.Error())
}
context.String(http.StatusOK, "姓名:"+s.Name+",班级:"+s.Classes)
})
engine.Run()
}

5
golang_frame/go_to_gin/go_to_download/main.go

@ -0,0 +1,5 @@
package main
func main() {
}

46
golang_frame/go_to_gin/go_to_group_router/main.go

@ -0,0 +1,46 @@
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
engine := gin.Default()
// 1、创建一个 路由分组,解决多路由操作
routerGroup := engine.Group("/user")
// 2.1、处理分请求 - 注册
routerGroup.POST("/register", func(context *gin.Context) {
context.Writer.WriteString("用户注册:" + context.FullPath())
})
// 2.2、处理分请求 - 查询
routerGroup.GET("/query", func(context *gin.Context) {
context.Writer.WriteString("用户查询:" + context.FullPath())
})
// 2.3、处理分请求 - 删除
routerGroup.DELETE("/id/:id", func(context *gin.Context) {
context.Writer.WriteString("用户删除:" + context.Param("id"))
})
// 3.1、【推荐】处理分请求 - 注册
routerGroup.POST("/register_s", RegisterHandle)
// 3.2、【推荐】处理分请求 - 查询
routerGroup.GET("/query_s", QueryHandle)
// 3.3、【推荐】处理分请求 - 删除
routerGroup.DELETE("/name/:name", DeleteIdHandle)
engine.Run()
}
func RegisterHandle(context *gin.Context) {
context.Writer.WriteString("用户注册:" + context.FullPath())
}
func QueryHandle(context *gin.Context) {
context.Writer.WriteString("用户查询:" + context.FullPath())
}
func DeleteIdHandle(context *gin.Context) {
context.Writer.WriteString("用户删除:" + context.Param("name"))
}

34
golang_frame/go_to_gin/go_to_hello/main.go

@ -0,0 +1,34 @@
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
// 1、默认的方式获取一个服务器引擎
// 5、存在较为原始处理 gin.New()
// 5.1、Default 相对 New 默认添加了 Logger 和 Recovery 中间件
engine := gin.Default()
// 3、设置请求处理接口处理
engine.GET("/hello", func(context *gin.Context) {
/**
这里存在较多返回处理类型
context.Writer.Write([]byte("请求路径:" + context.FullPath()))
context.Writer.WriteString("请求路径:" + context.FullPath())
context.String(http.StatusOK, "请求路径:" + context.FullPath())
context.JSON(http.StatusOK, gin.H{"path":"请求路径:" + context.FullPath()})
context.ProtoBuf(http.StatusOK, gin.H{"path":"请求路径:" + context.FullPath()})
context.YAML(http.StatusOK, gin.H{"path":"请求路径:" + context.FullPath()})
context.HTML(http.StatusOK, "index.tmpl", gin.H{"title": "请求路径:" + context.FullPath(),})
*/
context.Writer.Write([]byte("请求路径:" + context.FullPath()))
})
// 2、运行操作,并判断是否运行成功
// 4、这里可以在 engine.Run(":8090") 设置请求端口设置
if err := engine.Run(); err != nil {
panic(err.Error())
}
}

56
golang_frame/go_to_gin/go_to_http_handle/main.go

@ -0,0 +1,56 @@
package main
import "github.com/gin-gonic/gin"
func main() {
engine := gin.Default()
// 1、使用 http://127.0.0.1:8090/hello?name=zhangsan
// 4.1、分类处理请求
// engine.GET("/hello", iRouterFunc)
engine.Handle("GET", "/hello", func(context *gin.Context) {
/**
queryInfo := context.DefaultQuery("name", "这是默认") -- 存在默认值的获取参数值
queryInfo := context.Query("name") -- 匹配参数值
queryInfo, bool := context.GetQuery("name") -- 匹配参数值并返回是否匹配结果
queryInfos := context.QueryArray("names") --
queryInfos := context.QueryMap("names") --
queryInfos, bool := context.GetQueryArray("names") --
queryInfos, bool := context.GetQueryMap("names") --
queryInfos := context.BindQuery(&names) --
queryInfos := context.ShouldBindQuery(&names) --
*/
queryInfo := context.DefaultQuery("name", "这是默认")
context.Writer.Write([]byte("获取参数name=" + queryInfo))
})
// 2、使用 http://127.0.0.1:8090/login
// 4.2、分类处理请求
// engine.POST("/login", iRouterFunc)
engine.Handle("POST", "/login", func(context *gin.Context) {
/**
queryInfo := context.PostForm("f_xxx.name") --
queryInfos := context.PostFormArray("f_xxx.names") --
queryInfos, bool := context.GetPostForm("f_xxx.names") --
queryInfos, bool := context.GetPostFormArray("f_xxx.names") --
queryInfos, bool := context.GetPostFormMap("f_xxx.names") --
*/
queryInfo := context.PostForm("f_xxx.name")
context.Writer.Write([]byte("获取参数name=" + queryInfo))
})
// 3、使用 http://127.0.0.1:8090/user/:id
// 4.3、分类处理请求
// engine.DELETE("/user/:id", iRouterFunc)
engine.Handle("DELETE", "/user/:id", func(context *gin.Context) {
/**
queryInfo := context.Param("name") -- 匹配":xx"类参数值
*/
queryInfo := context.Param("id")
context.Writer.Write([]byte("删除的id=" + queryInfo))
})
engine.Run()
}

33
golang_frame/go_to_gin/go_to_middleware/main.go

@ -0,0 +1,33 @@
package main
import (
"fmt"
"github.com/gin-gonic/gin"
)
func main() {
engine := gin.Default()
engine.Use(RequertMiddleware())
engine.GET("/hello", HelloHandle)
engine.Run()
}
func HelloHandle(context *gin.Context) {
context.Writer.WriteString("请求成功!")
}
func RequertMiddleware() gin.HandlerFunc {
return func(context *gin.Context) {
fmt.Println("请求PATH:" + context.FullPath())
// 1、中断 后继续执行其他中间件
// 2、其他执行完毕后,再继续执行
fmt.Println("请求函数:" + context.Request.Method)
}
}

56
golang_frame/go_to_gin/go_to_resp_formate/main.go

@ -0,0 +1,56 @@
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
// 0、请求为 http://127.0.0.1:8080/xxx
engine := gin.Default()
// 1、使用 context.Writer.Write([]byte(""))
engine.GET("byteHello", func(context *gin.Context) {
context.Writer.Write([]byte("请求为:" + context.FullPath()))
})
// 2、使用 context.Writer.WriteString("")
engine.GET("stringHello", func(context *gin.Context) {
context.Writer.WriteString("请求为:" + context.FullPath())
})
// 3、使用 context.JSON(http.StatusOK, map[string]interface{}{"":""})
engine.GET("jsonMapHello", func(context *gin.Context) {
context.JSON(http.StatusOK, map[string]interface{}{
"resp": "请求为:" + context.FullPath(),
})
})
// 4、使用 context.JSON(http.StatusOK, interface{})
engine.GET("jsonStructHello", func(context *gin.Context) {
resp := Response{Code: http.StatusOK, Message: "OK", Data: "请求为:" + context.FullPath()}
context.JSON(http.StatusOK, &resp)
})
// 5.0、使用静态资源展示时,需要执行 engine.Static("xxx", "xxx")
// 参数1:表示服务映射路径 参数2:实际路径设置
engine.Static("/img", "./src/data_frame/go_to_gin/go_to_resp_formate/img")
// 5.1、使用 HTML 模板时,需要执行 engine.LoadHTMLGlob("./xxx/*")
// 注意:这里路径是相对的(./是你当前的工程目录,并不是该go文件所对应的目录。)
engine.LoadHTMLGlob("./src/data_frame/go_to_gin/go_to_resp_formate/html/*")
// 5.2、使用 context.HTML(http.StatusOK, "xxx.html", gin.H{})
engine.GET("htmlHello", func(context *gin.Context) {
context.HTML(http.StatusOK, "index.html", gin.H{
"resp": "请求为:" + context.FullPath(),
})
})
engine.Run()
}
type Response struct {
Code int
Message string
Data interface{}
}

5
golang_frame/go_to_gorilla_mux/go_to_hello/main.go

@ -0,0 +1,5 @@
package main
func main() {
}

30
golang_frame/go_to_iris/go_to_band_data/main.go

@ -0,0 +1,30 @@
package main
import "github.com/beego/beego/v2/server/web"
type MainController struct {
web.Controller
}
func (this *MainController) Get() {
this.Ctx.WriteString("hello world - get")
}
func (this *MainController) Post() {
this.Ctx.WriteString("hello world - post")
}
func (this *MainController) Delete() {
this.Ctx.WriteString("hello world - post")
}
/**
main 获取请求内参数
*/
func main() {
// 请求:127.0.0.1:8080/hello?name=zhangsan
web.Router("/hello", &MainController{})
// 请求:127.0.0.1:8080/user/:id
web.Router("/user/:id", &MainController{})
web.Run("127.0.0.1:8080")
}

5
golang_frame/go_to_iris/go_to_download/main.go

@ -0,0 +1,5 @@
package main
func main() {
}

12
golang_frame/go_to_iris/go_to_hello/main.go

@ -0,0 +1,12 @@
package main
import "github.com/kataras/iris/v12"
func main() {
//1.创建app结构体对象
app := iris.New()
//2.端口监听
app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
////application.Run(iris.Addr(":8080"))//第一种
//application.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed)) //第二种
}

5
golang_frame/go_to_iris/go_to_resp_formate/main.go

@ -0,0 +1,5 @@
package main
func main() {
}

5
golang_frame/go_to_muxie/go_to_hello/main.go

@ -0,0 +1,5 @@
package main
func main() {
}

52
golang_learn/data_func/go_to_base64/main.go

@ -0,0 +1,52 @@
package main
import (
"encoding/base64"
"fmt"
"io/ioutil"
"os"
)
func main() {
// 读取Base64
k := ImagesToBase("D:\\EPWork\\goland\\workspace\\golang_learn\\src\\data_func\\go_to_base64\\rc.ico")
fmt.Print(k)
}
// 图片转Base64
func ImagesToBase64(str_images string) string {
//读原图片
ff, _ := os.Open(str_images)
defer ff.Close()
sourcebuffer := make([]byte, 500000)
n, _ := ff.Read(sourcebuffer)
//base64压缩
return base64.StdEncoding.EncodeToString(sourcebuffer[:n])
}
// 图片转Base64 - 数组
func ImagesToBase(str_images string) []byte {
//读原图片
ff, _ := os.Open(str_images)
defer ff.Close()
sourcebuffer := make([]byte, 500000)
n, _ := ff.Read(sourcebuffer)
sourcestring := base64.StdEncoding.EncodeToString(sourcebuffer[:n])
return []byte(sourcestring)
}
// Base64转图片
func Base64ToImage(sourcestring []byte) {
// 写入临时文件
ioutil.WriteFile("a.png.txt", sourcestring, 0667)
// 读取临时文件
cc, _ := ioutil.ReadFile("a.png.txt")
// 解压
dist, _ := base64.StdEncoding.DecodeString(string(cc))
// 写入新文件
f, _ := os.OpenFile("xx.png", os.O_RDWR|os.O_CREATE, os.ModePerm)
defer f.Close()
f.Write(dist)
return
}

15
golang_learn/data_func/go_to_cmd/main.go

@ -0,0 +1,15 @@
package main
import (
"fmt"
"os/exec"
)
// 失败!
func main() {
err := exec.Command("cmd.exe", "/c", "D:\\EPWork\\goland\\workspace\\golang_learn\\src\\data_func\\go_to_cmd\\a.vbs").Run()
if err != nil {
fmt.Printf("Error: %s", err.Error())
}
}

25
golang_learn/data_func/go_to_copy_a57/main.go

@ -0,0 +1,25 @@
package main
import (
"io"
"os"
"strconv"
)
func main() {
//os.Mkdir("./0",os.ModePerm)
//os.Mkdir("./0/0",os.ModePerm)
for i := 1; i < 160001; i++ {
CopyFile("0.jpg", strconv.Itoa(i)+".jpg")
}
}
func CopyFile(src, des string) (w int64, err error) {
srcFile, _ := os.Open(src)
defer srcFile.Close()
desFile, _ := os.Create(des)
defer desFile.Close()
return io.Copy(desFile, srcFile)
}

49
golang_learn/data_func/go_to_dir/writeDir/main.go

@ -0,0 +1,49 @@
package main
import (
"fmt"
"os"
)
// 判断文件夹是否存在
func PathExists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil {
return true, nil
}
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
func main() {
var dirs [...]string
dirs[0] = "mysql"
dirs[1] = "001.项目管理/002.XX管理"
var _dir string
for _, x := range dirs {
_dir = "./" + x
exist, err := PathExists(_dir)
if err != nil {
fmt.Printf("get dir error![%v]\n", err)
continue
}
if exist {
fmt.Printf("has dir![%v]\n", _dir)
} else {
fmt.Printf("no dir![%v]\n", _dir)
// 创建文件夹
err := os.Mkdir(_dir, os.ModePerm)
if err != nil {
fmt.Printf("mkdir failed![%v]\n", err)
} else {
fmt.Printf("mkdir success!\n")
}
}
}
}

35
golang_learn/data_func/go_to_file_path/go/main.go

@ -0,0 +1,35 @@
/**
* @Author: VIVIMAN
* @Description:
* @File: main
* @Version: 1.0.0
* @Date: 2021/5/10 18:21
*/
package main
import (
"fmt"
"io/ioutil"
"os"
)
func main() {
// ./是你当前的工程目录,并不是该go文件所对应的目录。
// 比如myProject/src/main/main.go
// main.go里使用./,其路径不是myProject/src/main/,而是myProject/
const dataFile = "./src/data_func/go_to_file_path/json/m.json"
// _, filename, _, _ := runtime.Caller(1)
// datapath := path.Join(path.Dir(filename), dataFile)
datapath := dataFile
fmt.Println(datapath)
//打开文件
file, err := os.Open(datapath)
if err != nil {
fmt.Println("出错了...")
}
//当函数return时,关闭文件
defer file.Close()
fmt.Println(ioutil.ReadAll(file))
}

37
golang_learn/data_func/go_to_flag/demo01/main.go

@ -0,0 +1,37 @@
package main
import "flag"
import "fmt"
// 定义命令行参数对应的变量,这三个变量都是指针类型
var cliName = flag.String("name", "nick", "Input Your Name")
var cliAge = flag.Int("age", 28, "Input Your Age")
var cliGender = flag.String("gender", "male", "Input Your Gender")
// 定义一个值类型的命令行参数变量,在 Init() 函数中对其初始化
// 因此,命令行参数对应变量的定义和初始化是可以分开的
var cliFlag int
func Init() {
flag.IntVar(&cliFlag, "flagname", 1234, "Just for demo")
}
func main() {
// 初始化变量 cliFlag
Init()
// 把用户传递的命令行参数解析为对应变量的值
flag.Parse()
// flag.Args() 函数返回没有被解析的命令行参数
// func NArg() 函数返回没有被解析的命令行参数的个数
fmt.Printf("args=%s, num=%d\n", flag.Args(), flag.NArg())
for i := 0; i != flag.NArg(); i++ {
fmt.Printf("arg[%d]=%s\n", i, flag.Arg(i))
}
// 输出命令行参数
fmt.Println("name=", *cliName)
fmt.Println("age=", *cliAge)
fmt.Println("gender=", *cliGender)
fmt.Println("flagname=", cliFlag)
}

20
golang_learn/data_func/go_to_fyne/demo1/main.go

@ -0,0 +1,20 @@
package main
import (
"fyne.io/fyne/app"
"fyne.io/fyne/widget"
)
func main() {
app := app.New()
w := app.NewWindow("Hello")
w.SetContent(widget.NewVBox(
widget.NewLabel("Hello Fyne!"),
widget.NewButton("Quit", func() {
app.Quit()
}),
))
w.ShowAndRun()
}

89
golang_learn/data_func/go_to_fyne/demo2/main.go

@ -0,0 +1,89 @@
// Package main provides various examples of Fyne API capabilities
package main
import (
"fmt"
"net/url"
"fyne.io/fyne"
"fyne.io/fyne/app"
"fyne.io/fyne/canvas"
"fyne.io/fyne/cmd/fyne_demo/screens"
"fyne.io/fyne/layout"
"fyne.io/fyne/theme"
"fyne.io/fyne/widget"
)
const preferenceCurrentTab = "currentTab"
func parseURL(urlStr string) *url.URL {
link, err := url.Parse(urlStr)
if err != nil {
fyne.LogError("Could not parse URL", err)
}
return link
}
func welcomeScreen(a fyne.App) fyne.CanvasObject {
//logo := canvas.NewImageFromResource(data.FyneScene)
logo := canvas.NewImageFromResource(nil)
logo.SetMinSize(fyne.NewSize(228, 167))
return widget.NewVBox(
widget.NewLabelWithStyle("欢迎您!", fyne.TextAlignCenter, fyne.TextStyle{Bold: true}),
layout.NewSpacer(),
widget.NewHBox(layout.NewSpacer(), logo, layout.NewSpacer()),
widget.NewHBox(layout.NewSpacer(),
widget.NewHyperlink("fyne.io", parseURL("https://fyne.io/")),
widget.NewLabel("-"),
widget.NewHyperlink("documentation", parseURL("https://fyne.io/develop/")),
widget.NewLabel("-"),
widget.NewHyperlink("sponsor", parseURL("https://github.com/sponsors/fyne-io")),
layout.NewSpacer(),
),
layout.NewSpacer(),
widget.NewGroup("Theme",
fyne.NewContainerWithLayout(layout.NewGridLayout(2),
widget.NewButton("Dark", func() {
a.Settings().SetTheme(theme.DarkTheme())
}),
widget.NewButton("Light", func() {
a.Settings().SetTheme(theme.LightTheme())
}),
),
),
)
}
func main() {
// a := app.NewWindow("io.fyne.demo")
a := app.New()
w := a.NewWindow("样例")
a.SetIcon(theme.FyneLogo())
w.SetMainMenu(fyne.NewMainMenu(fyne.NewMenu("File",
fyne.NewMenuItem("新增", func() { fmt.Println("菜单新增") }),
// a quit item will be appended to our first menu
), fyne.NewMenu("编辑",
fyne.NewMenuItem("剪切", func() { fmt.Println("菜单剪切") }),
fyne.NewMenuItem("复制", func() { fmt.Println("菜单复制") }),
fyne.NewMenuItem("粘贴", func() { fmt.Println("菜单粘贴") }),
)))
// w.SetMaster()
tabs := widget.NewTabContainer(
widget.NewTabItemWithIcon("欢迎", theme.HomeIcon(), welcomeScreen(a)),
widget.NewTabItemWithIcon("小部件", theme.ContentCopyIcon(), screens.WidgetScreen()),
widget.NewTabItemWithIcon("图形", theme.DocumentCreateIcon(), screens.GraphicsScreen()),
widget.NewTabItemWithIcon("视窗", theme.ViewFullScreenIcon(), screens.DialogScreen(w)),
widget.NewTabItemWithIcon("高级", theme.SettingsIcon(), screens.AdvancedScreen(w)))
tabs.SetTabLocation(widget.TabLocationLeading)
//tabs.SelectTabIndex(a.Preferences().Int(preferenceCurrentTab))
w.SetContent(tabs)
w.ShowAndRun()
//a.Preferences().SetInt(preferenceCurrentTab, tabs.CurrentTabIndex())
}

3
golang_learn/data_func/go_to_godotenv/main.env

@ -0,0 +1,3 @@
xxx="root"
vvv="123456"
aaa="127.0.0.1"

21
golang_learn/data_func/go_to_icon/main.exe.manifest

@ -0,0 +1,21 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity
version="1.0.0.0"
processorArchitecture="x86"
name="controls"
type="win32"
></assemblyIdentity>
<dependency>
<dependentAssembly>
<assemblyIdentity
type="win32"
name="Microsoft.Windows.Common-Controls"
version="6.0.0.0"
processorArchitecture="*"
publicKeyToken="6595b64144ccf1df"
language="*"
></assemblyIdentity>
</dependentAssembly>
</dependency>
</assembly>

56
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_N03.go

@ -0,0 +1,56 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_N03 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_N03SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_N03SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
N0301 string `xml:"N0301,attr"` // 读取flag属性 N0301
N0302 string `xml:"N0302,attr"` // 读取flag属性 N0302
N0303 string `xml:"N0303,attr"` // 读取flag属性 N0303
N0304 string `xml:"N0304,attr"` // 读取flag属性 N0304
N0305 string `xml:"N0305,attr"` // 读取flag属性 N0305
N0306 string `xml:"N0306,attr"` // 读取flag属性 N0306
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
N0307 string `xml:"N0307,attr"` // 读取flag属性 N0307
N0308 string `xml:"N0308,attr"` // 读取flag属性 N0308
N0309 string `xml:"N0309,attr"` // 读取flag属性 N0309
N0310 string `xml:"N0310,attr"` // 读取flag属性 N0310
N0311 string `xml:"N0311,attr"` // 读取flag属性 N0311
N0312 string `xml:"N0312,attr"` // 读取flag属性 N0312
N0313 string `xml:"N0313,attr"` // 读取flag属性 N0313
N0314 string `xml:"N0314,attr"` // 读取flag属性 N0314
N0399 string `xml:"N0399,attr"` // 读取flag属性 N0399
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_N03(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_N03 (EUUID,N0307,N0308,N0309,N0310,N0311,N0312,N0313,N0314,N0399,RNUM,SID,OUUID,UNID,RPT,TP,N0301,N0302,N0303,N0304,N0305,N0306,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_N03{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_N03...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.UNID, rows.RPT, rows.TP, rows.N0301, rows.N0302, rows.N0303, rows.N0304, rows.N0305, rows.N0306, rows.OUUID, rows.SID, rows.RNUM, rows.N0307, rows.N0308, rows.N0309, rows.N0310, rows.N0311, rows.N0312, rows.N0313, rows.N0314, rows.N0399, rows.ORDERBY)
}
}

53
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_N04.go

@ -0,0 +1,53 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_N04 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_N04SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_N04SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
N0401 string `xml:"N0401,attr"` // 读取flag属性 N0401
N0402 string `xml:"N0402,attr"` // 读取flag属性 N0402
N0403 string `xml:"N0403,attr"` // 读取flag属性 N0403
N0404 string `xml:"N0404,attr"` // 读取flag属性 N0404
N0405 string `xml:"N0405,attr"` // 读取flag属性 N0405
N0406 string `xml:"N0406,attr"` // 读取flag属性 N0406
N0407 string `xml:"N0407,attr"` // 读取flag属性 N0407
N0408 string `xml:"N0408,attr"` // 读取flag属性 N0408
N0499 string `xml:"N0499,attr"` // 读取flag属性 N0499
N0409 string `xml:"N0409,attr"` // 读取flag属性 N0409
N0410 string `xml:"N0410,attr"` // 读取flag属性 N0410
N0411 string `xml:"N0411,attr"` // 读取flag属性 N0411
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_N04(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_N04 (EUUID,N0405,N0406,N0407,N0408,N0499,N0409,N0410,N0411,N0404,N0403,UNID,RPT,TP,OUUID,SID,RNUM,N0401,N0402,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_N04{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_N04...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.UNID, rows.RPT, rows.TP, rows.OUUID, rows.SID, rows.RNUM, rows.N0401, rows.N0402, rows.N0403, rows.N0404, rows.N0405, rows.N0406, rows.N0407, rows.N0408, rows.N0499, rows.N0409, rows.N0410, rows.N0411, rows.ORDERBY)
}
}

49
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_N05.go

@ -0,0 +1,49 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_N05 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_N05SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_N05SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
N0501 string `xml:"N0501,attr"` // 读取flag属性 N0501
N0502 string `xml:"N0502,attr"` // 读取flag属性 N0502
N0503 string `xml:"N0503,attr"` // 读取flag属性 N0503
N0504 string `xml:"N0504,attr"` // 读取flag属性 N0504
N0505 string `xml:"N0505,attr"` // 读取flag属性 N0505
N0506 string `xml:"N0506,attr"` // 读取flag属性 N0506
N0507 string `xml:"N0507,attr"` // 读取flag属性 N0507
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
N0599 string `xml:"N0599,attr"` // 读取flag属性 N0599
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_N05(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_N05 (EUUID,N0599,RNUM,OUUID,N0507,N0506,N0505,N0504,N0503,N0502,N0501,TP,RPT,UNID,SID,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_N05{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_N05...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.UNID, rows.RPT, rows.TP, rows.N0501, rows.N0502, rows.N0503, rows.N0504, rows.N0505, rows.N0506, rows.N0507, rows.OUUID, rows.RNUM, rows.N0599, rows.ORDERBY)
}
}

42
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_P01.go

@ -0,0 +1,42 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_P01 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_P01SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_P01SRow struct {
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
P0101 string `xml:"P0101,attr"` // 读取flag属性 P0101
P0102 string `xml:"P0102,attr"` // 读取flag属性 P0102
P0103 string `xml:"P0103,attr"` // 读取flag属性 P0103
P0104 string `xml:"P0104,attr"` // 读取flag属性 P0104
P0199 string `xml:"P0199,attr"` // 读取flag属性 P0199
}
func InsertM_P01(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_P01 (OUUID,UNID,RPT,TP,P0101,P0102,P0103,P0104,P0199) VALUE (?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_P01{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_P01...")
for _, rows := range v.Row {
stmt.Exec(rows.OUUID, rows.UNID, rows.RPT, rows.TP, rows.P0101, rows.P0102, rows.P0103, rows.P0104, rows.P0199)
}
}

61
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_P02.go

@ -0,0 +1,61 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_P02 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_P02SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_P02SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
P0201 string `xml:"P0201,attr"` // 读取flag属性 P0201
P0202 string `xml:"P0202,attr"` // 读取flag属性 P0202
P0203 string `xml:"P0203,attr"` // 读取flag属性 P0203
P0204 string `xml:"P0204,attr"` // 读取flag属性 P0204
P0205 string `xml:"P0205,attr"` // 读取flag属性 P0205
P0206 string `xml:"P0206,attr"` // 读取flag属性 P0206
P0207 string `xml:"P0207,attr"` // 读取flag属性 P0207
P0208 string `xml:"P0208,attr"` // 读取flag属性 P0208
P0209 string `xml:"P0209,attr"` // 读取flag属性 P0209
P0210 string `xml:"P0210,attr"` // 读取flag属性 P0210
P0211 string `xml:"P0211,attr"` // 读取flag属性 P0211
P0212 string `xml:"P0212,attr"` // 读取flag属性 P0212
P0213 string `xml:"P0213,attr"` // 读取flag属性 P0213
P0214 string `xml:"P0214,attr"` // 读取flag属性 P0214
P0215 string `xml:"P0215,attr"` // 读取flag属性 P0215
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
P0211_1 string `xml:"P0211_1,attr"` // 读取flag属性 P0211_1
P0213_1 string `xml:"P0213_1,attr"` // 读取flag属性 P0213_1
P0214_1 string `xml:"P0214_1,attr"` // 读取flag属性 P0214_1
P0216 string `xml:"P0216,attr"` // 读取flag属性 P0216
P0299 string `xml:"P0299,attr"` // 读取flag属性 P0299
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_P02(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_P02 (EUUID,P0211,P0212,P0213,P0214,P0215,OUUID,RNUM,P0211_1,P0213_1,P0214_1,P0216,P0299,P0210,P0209,SID,UNID,RPT,TP,P0201,P0202,P0203,P0204,P0205,P0206,P0207,P0208,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_P02{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_P02...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.UNID, rows.RPT, rows.TP, rows.P0201, rows.P0202, rows.P0203, rows.P0204, rows.P0205, rows.P0206, rows.P0207, rows.P0208, rows.P0209, rows.P0210, rows.P0211, rows.P0212, rows.P0213, rows.P0214, rows.P0215, rows.OUUID, rows.RNUM, rows.P0211_1, rows.P0213_1, rows.P0214_1, rows.P0216, rows.P0299, rows.ORDERBY)
}
}

61
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_P03.go

@ -0,0 +1,61 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_P03 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_P03SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_P03SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
P0301 string `xml:"P0301,attr"` // 读取flag属性 P0301
P0302 string `xml:"P0302,attr"` // 读取flag属性 P0302
P0303 string `xml:"P0303,attr"` // 读取flag属性 P0303
P0304 string `xml:"P0304,attr"` // 读取flag属性 P0304
P0305 string `xml:"P0305,attr"` // 读取flag属性 P0305
P0306 string `xml:"P0306,attr"` // 读取flag属性 P0306
P0307 string `xml:"P0307,attr"` // 读取flag属性 P0307
P0308 string `xml:"P0308,attr"` // 读取flag属性 P0308
P0309 string `xml:"P0309,attr"` // 读取flag属性 P0309
P0310 string `xml:"P0310,attr"` // 读取flag属性 P0310
P0311 string `xml:"P0311,attr"` // 读取flag属性 P0311
P0312 string `xml:"P0312,attr"` // 读取flag属性 P0312
P0313 string `xml:"P0313,attr"` // 读取flag属性 P0313
P0314 string `xml:"P0314,attr"` // 读取flag属性 P0314
P0315 string `xml:"P0315,attr"` // 读取flag属性 P0315
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
P0311_1 string `xml:"P0311_1,attr"` // 读取flag属性 P0311_1
P0313_1 string `xml:"P0313_1,attr"` // 读取flag属性 P0313_1
P0314_1 string `xml:"P0314_1,attr"` // 读取flag属性 P0314_1
P0316 string `xml:"P0316,attr"` // 读取flag属性 P0316
P0399 string `xml:"P0399,attr"` // 读取flag属性 P0399
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_P03(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_P03 (EUUID,P0311,P0312,P0313,P0314,P0315,OUUID,RNUM,P0311_1,P0313_1,P0314_1,P0316,P0399,P0310,P0309,SID,UNID,RPT,TP,P0301,P0302,P0303,P0304,P0305,P0306,P0307,P0308,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_P03{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_P03...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.UNID, rows.RPT, rows.TP, rows.P0301, rows.P0302, rows.P0303, rows.P0304, rows.P0305, rows.P0306, rows.P0307, rows.P0308, rows.P0309, rows.P0310, rows.P0311, rows.P0312, rows.P0313, rows.P0314, rows.P0315, rows.OUUID, rows.RNUM, rows.P0311_1, rows.P0313_1, rows.P0314_1, rows.P0316, rows.P0399, rows.ORDERBY)
}
}

52
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q01.go

@ -0,0 +1,52 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_Q01 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_Q01SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_Q01SRow struct {
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
Q0101 string `xml:"Q0101,attr"` // 读取flag属性 Q0101
Q0102 string `xml:"Q0102,attr"` // 读取flag属性 Q0102
Q0103 string `xml:"Q0103,attr"` // 读取flag属性 Q0103
Q0104 string `xml:"Q0104,attr"` // 读取flag属性 Q0104
Q0105 string `xml:"Q0105,attr"` // 读取flag属性 Q0105
Q0106 string `xml:"Q0106,attr"` // 读取flag属性 Q0106
Q0107 string `xml:"Q0107,attr"` // 读取flag属性 Q0107
Q0108 string `xml:"Q0108,attr"` // 读取flag属性 Q0108
Q0109 string `xml:"Q0109,attr"` // 读取flag属性 Q0109
Q0110 string `xml:"Q0110,attr"` // 读取flag属性 Q0110
Q0111 string `xml:"Q0111,attr"` // 读取flag属性 Q0111
Q0112 string `xml:"Q0112,attr"` // 读取flag属性 Q0112
Q0199 string `xml:"Q0199,attr"` // 读取flag属性 Q0199
Q0113 string `xml:"Q0113,attr"` // 读取flag属性 Q0113
Q0114 string `xml:"Q0114,attr"` // 读取flag属性 Q0114
}
func InsertM_Q01(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_Q01 (OUUID,Q0113,Q0199,Q0112,Q0111,Q0110,Q0109,Q0108,Q0107,Q0106,Q0105,Q0104,Q0103,Q0102,Q0101,TP,RPT,UNID,Q0114) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_Q01{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_Q01...")
for _, rows := range v.Row {
stmt.Exec(rows.OUUID, rows.UNID, rows.RPT, rows.TP, rows.Q0101, rows.Q0102, rows.Q0103, rows.Q0104, rows.Q0105, rows.Q0106, rows.Q0107, rows.Q0108, rows.Q0109, rows.Q0110, rows.Q0111, rows.Q0112, rows.Q0199, rows.Q0113, rows.Q0114)
}
}

62
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q09.go

@ -0,0 +1,62 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_Q09 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_Q09SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_Q09SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
Q0901 string `xml:"Q0901,attr"` // 读取flag属性 Q0901
Q0902 string `xml:"Q0902,attr"` // 读取flag属性 Q0902
Q0903 string `xml:"Q0903,attr"` // 读取flag属性 Q0903
Q0904 string `xml:"Q0904,attr"` // 读取flag属性 Q0904
Q0905 string `xml:"Q0905,attr"` // 读取flag属性 Q0905
Q0906 string `xml:"Q0906,attr"` // 读取flag属性 Q0906
Q0907 string `xml:"Q0907,attr"` // 读取flag属性 Q0907
Q0908 string `xml:"Q0908,attr"` // 读取flag属性 Q0908
Q0909 string `xml:"Q0909,attr"` // 读取flag属性 Q0909
Q0910 string `xml:"Q0910,attr"` // 读取flag属性 Q0910
Q0911 string `xml:"Q0911,attr"` // 读取flag属性 Q0911
Q0912 string `xml:"Q0912,attr"` // 读取flag属性 Q0912
Q0913 string `xml:"Q0913,attr"` // 读取flag属性 Q0913
Q0914 string `xml:"Q0914,attr"` // 读取flag属性 Q0914
Q0915 string `xml:"Q0915,attr"` // 读取flag属性 Q0915
Q0916 string `xml:"Q0916,attr"` // 读取flag属性 Q0916
Q0917 string `xml:"Q0917,attr"` // 读取flag属性 Q0917
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
Q0910_1 string `xml:"Q0910_1,attr"` // 读取flag属性 Q0910_1
Q0913_1 string `xml:"Q0913_1,attr"` // 读取flag属性 Q0913_1
Q0914_1 string `xml:"Q0914_1,attr"` // 读取flag属性 Q0914_1
Q0999 string `xml:"Q0999,attr"` // 读取flag属性 Q0999
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_Q09(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_Q09 (EUUID,Q0913,Q0914,Q0915,Q0916,Q0917,OUUID,SID,RNUM,Q0910_1,Q0913_1,Q0914_1,Q0999,Q0912,Q0911,Q0910,UNID,RPT,TP,Q0901,Q0902,Q0903,Q0904,Q0905,Q0906,Q0907,Q0908,Q0909,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_Q09{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_Q09...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.UNID, rows.RPT, rows.TP, rows.Q0901, rows.Q0902, rows.Q0903, rows.Q0904, rows.Q0905, rows.Q0906, rows.Q0907, rows.Q0908, rows.Q0909, rows.Q0910, rows.Q0911, rows.Q0912, rows.Q0913, rows.Q0914, rows.Q0915, rows.Q0916, rows.Q0917, rows.OUUID, rows.SID, rows.RNUM, rows.Q0910_1, rows.Q0913_1, rows.Q0914_1, rows.Q0999, rows.ORDERBY)
}
}

63
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q10.go

@ -0,0 +1,63 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_Q10 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_Q10SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_Q10SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
Q1001 string `xml:"Q1001,attr"` // 读取flag属性 Q1001
Q1002 string `xml:"Q1002,attr"` // 读取flag属性 Q1002
Q1003 string `xml:"Q1003,attr"` // 读取flag属性 Q1003
Q1004 string `xml:"Q1004,attr"` // 读取flag属性 Q1004
Q1005 string `xml:"Q1005,attr"` // 读取flag属性 Q1005
Q1006 string `xml:"Q1006,attr"` // 读取flag属性 Q1006
Q1007 string `xml:"Q1007,attr"` // 读取flag属性 Q1007
Q1008 string `xml:"Q1008,attr"` // 读取flag属性 Q1008
Q1009 string `xml:"Q1009,attr"` // 读取flag属性 Q1009
Q1010 string `xml:"Q1010,attr"` // 读取flag属性 Q1010
Q1011 string `xml:"Q1011,attr"` // 读取flag属性 Q1011
Q1012 string `xml:"Q1012,attr"` // 读取flag属性 Q1012
Q1013 string `xml:"Q1013,attr"` // 读取flag属性 Q1013
Q1014 string `xml:"Q1014,attr"` // 读取flag属性 Q1014
Q1015 string `xml:"Q1015,attr"` // 读取flag属性 Q1015
Q1016 string `xml:"Q1016,attr"` // 读取flag属性 Q1016
Q1017 string `xml:"Q1017,attr"` // 读取flag属性 Q1017
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
Q1010_1 string `xml:"Q1010_1,attr"` // 读取flag属性 Q1010_1
Q1013_1 string `xml:"Q1013_1,attr"` // 读取flag属性 Q1013_1
Q1014_1 string `xml:"Q1014_1,attr"` // 读取flag属性 Q1014_1
Q1018 string `xml:"Q1018,attr"` // 读取flag属性 Q1018
Q1099 string `xml:"Q1099,attr"` // 读取flag属性 Q1099
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_Q10(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_Q10 (EUUID,Q1013,Q1014,Q1015,Q1016,Q1017,OUUID,SID,RNUM,Q1010_1,Q1013_1,Q1014_1,Q1018,Q1099,Q1012,Q1011,UNID,RPT,TP,Q1001,Q1002,Q1003,Q1004,Q1005,Q1006,Q1007,Q1008,Q1009,Q1010,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_Q10{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_Q10...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.UNID, rows.RPT, rows.TP, rows.Q1001, rows.Q1002, rows.Q1003, rows.Q1004, rows.Q1005, rows.Q1006, rows.Q1007, rows.Q1008, rows.Q1009, rows.Q1010, rows.Q1011, rows.Q1012, rows.Q1013, rows.Q1014, rows.Q1015, rows.Q1016, rows.Q1017, rows.OUUID, rows.SID, rows.RNUM, rows.Q1010_1, rows.Q1013_1, rows.Q1014_1, rows.Q1018, rows.Q1099, rows.ORDERBY)
}
}

62
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q11.go

@ -0,0 +1,62 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_Q11 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_Q11SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_Q11SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
Q1101 string `xml:"Q1101,attr"` // 读取flag属性 Q1101
Q1102 string `xml:"Q1102,attr"` // 读取flag属性 Q1102
Q1103 string `xml:"Q1103,attr"` // 读取flag属性 Q1103
Q1104 string `xml:"Q1104,attr"` // 读取flag属性 Q1104
Q1105 string `xml:"Q1105,attr"` // 读取flag属性 Q1105
Q1106 string `xml:"Q1106,attr"` // 读取flag属性 Q1106
Q1107 string `xml:"Q1107,attr"` // 读取flag属性 Q1107
Q1108 string `xml:"Q1108,attr"` // 读取flag属性 Q1108
Q1109 string `xml:"Q1109,attr"` // 读取flag属性 Q1109
Q1110 string `xml:"Q1110,attr"` // 读取flag属性 Q1110
Q1111 string `xml:"Q1111,attr"` // 读取flag属性 Q1111
Q1112 string `xml:"Q1112,attr"` // 读取flag属性 Q1112
Q1113 string `xml:"Q1113,attr"` // 读取flag属性 Q1113
Q1114 string `xml:"Q1114,attr"` // 读取flag属性 Q1114
Q1115 string `xml:"Q1115,attr"` // 读取flag属性 Q1115
Q1116 string `xml:"Q1116,attr"` // 读取flag属性 Q1116
Q1117 string `xml:"Q1117,attr"` // 读取flag属性 Q1117
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
Q1110_1 string `xml:"Q1110_1,attr"` // 读取flag属性 Q1110_1
Q1113_1 string `xml:"Q1113_1,attr"` // 读取flag属性 Q1113_1
Q1114_1 string `xml:"Q1114_1,attr"` // 读取flag属性 Q1114_1
Q1199 string `xml:"Q1199,attr"` // 读取flag属性 Q1199
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_Q11(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_Q11 (EUUID,Q1113,Q1114,Q1115,Q1116,Q1117,OUUID,SID,RNUM,Q1110_1,Q1113_1,Q1114_1,Q1199,Q1112,Q1111,Q1110,UNID,RPT,TP,Q1101,Q1102,Q1103,Q1104,Q1105,Q1106,Q1107,Q1108,Q1109,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_Q11{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_Q11...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.UNID, rows.RPT, rows.TP, rows.Q1101, rows.Q1102, rows.Q1103, rows.Q1104, rows.Q1105, rows.Q1106, rows.Q1107, rows.Q1108, rows.Q1109, rows.Q1110, rows.Q1111, rows.Q1112, rows.Q1113, rows.Q1114, rows.Q1115, rows.Q1116, rows.Q1117, rows.OUUID, rows.SID, rows.RNUM, rows.Q1110_1, rows.Q1113_1, rows.Q1114_1, rows.Q1199, rows.ORDERBY)
}
}

52
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q12.go

@ -0,0 +1,52 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_Q12 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_Q12SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_Q12SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
Q1201 string `xml:"Q1201,attr"` // 读取flag属性 Q1201
Q1202 string `xml:"Q1202,attr"` // 读取flag属性 Q1202
Q1203 string `xml:"Q1203,attr"` // 读取flag属性 Q1203
Q1204 string `xml:"Q1204,attr"` // 读取flag属性 Q1204
Q1205 string `xml:"Q1205,attr"` // 读取flag属性 Q1205
Q1206 string `xml:"Q1206,attr"` // 读取flag属性 Q1206
Q1207 string `xml:"Q1207,attr"` // 读取flag属性 Q1207
Q1208 string `xml:"Q1208,attr"` // 读取flag属性 Q1208
Q1209 string `xml:"Q1209,attr"` // 读取flag属性 Q1209
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
Q1206_1 string `xml:"Q1206_1,attr"` // 读取flag属性 Q1206_1
Q1299 string `xml:"Q1299,attr"` // 读取flag属性 Q1299
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_Q12(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_Q12 (EUUID,Q1299,Q1206_1,RNUM,SID,OUUID,Q1209,Q1208,Q1207,Q1206,Q1205,Q1204,Q1203,Q1202,Q1201,TP,RPT,UNID,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_Q12{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_Q12...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.UNID, rows.RPT, rows.TP, rows.Q1201, rows.Q1202, rows.Q1203, rows.Q1204, rows.Q1205, rows.Q1206, rows.Q1207, rows.Q1208, rows.Q1209, rows.OUUID, rows.SID, rows.RNUM, rows.Q1206_1, rows.Q1299, rows.ORDERBY)
}
}

63
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_Q13.go

@ -0,0 +1,63 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_Q13 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_Q13SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_Q13SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
Q1301 string `xml:"Q1301,attr"` // 读取flag属性 Q1301
Q1302 string `xml:"Q1302,attr"` // 读取flag属性 Q1302
Q1303 string `xml:"Q1303,attr"` // 读取flag属性 Q1303
Q1304 string `xml:"Q1304,attr"` // 读取flag属性 Q1304
Q1305 string `xml:"Q1305,attr"` // 读取flag属性 Q1305
Q1306 string `xml:"Q1306,attr"` // 读取flag属性 Q1306
Q1307 string `xml:"Q1307,attr"` // 读取flag属性 Q1307
Q1308 string `xml:"Q1308,attr"` // 读取flag属性 Q1308
Q1309 string `xml:"Q1309,attr"` // 读取flag属性 Q1309
Q1310 string `xml:"Q1310,attr"` // 读取flag属性 Q1310
Q1311 string `xml:"Q1311,attr"` // 读取flag属性 Q1311
Q1312 string `xml:"Q1312,attr"` // 读取flag属性 Q1312
Q1313 string `xml:"Q1313,attr"` // 读取flag属性 Q1313
Q1314 string `xml:"Q1314,attr"` // 读取flag属性 Q1314
Q1315 string `xml:"Q1315,attr"` // 读取flag属性 Q1315
Q1316 string `xml:"Q1316,attr"` // 读取flag属性 Q1316
Q1317 string `xml:"Q1317,attr"` // 读取flag属性 Q1317
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
Q1310_1 string `xml:"Q1310_1,attr"` // 读取flag属性 Q1310_1
Q1313_1 string `xml:"Q1313_1,attr"` // 读取flag属性 Q1313_1
Q1314_1 string `xml:"Q1314_1,attr"` // 读取flag属性 Q1314_1
Q1318 string `xml:"Q1318,attr"` // 读取flag属性 Q1318
Q1399 string `xml:"Q1399,attr"` // 读取flag属性 Q1399
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
}
func InsertM_Q13(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_Q13 (EUUID,Q1313,Q1314,Q1315,Q1316,Q1317,OUUID,SID,RNUM,Q1310_1,Q1313_1,Q1314_1,Q1318,Q1399,Q1312,Q1311,UNID,RPT,TP,Q1301,Q1302,Q1303,Q1304,Q1305,Q1306,Q1307,Q1308,Q1309,Q1310,ORDERBY) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_Q13{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_Q13...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.UNID, rows.RPT, rows.TP, rows.Q1301, rows.Q1302, rows.Q1303, rows.Q1304, rows.Q1305, rows.Q1306, rows.Q1307, rows.Q1308, rows.Q1309, rows.Q1310, rows.Q1311, rows.Q1312, rows.Q1313, rows.Q1314, rows.Q1315, rows.Q1316, rows.Q1317, rows.OUUID, rows.SID, rows.RNUM, rows.Q1310_1, rows.Q1313_1, rows.Q1314_1, rows.Q1318, rows.Q1399, rows.ORDERBY)
}
}

42
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S01.go

@ -0,0 +1,42 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_S01 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_S01SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_S01SRow struct {
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
S0101 string `xml:"S0101,attr"` // 读取flag属性 S0101
S0102 string `xml:"S0102,attr"` // 读取flag属性 S0102
S0103 string `xml:"S0103,attr"` // 读取flag属性 S0103
S0104 string `xml:"S0104,attr"` // 读取flag属性 S0104
S0105 string `xml:"S0105,attr"` // 读取flag属性 S0105
}
func InsertM_S01(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_S01 (OUUID,UNID,RPT,TP,S0101,S0102,S0103,S0104,S0105) VALUE (?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_S01{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_S01...")
for _, rows := range v.Row {
stmt.Exec(rows.OUUID, rows.UNID, rows.RPT, rows.TP, rows.S0101, rows.S0102, rows.S0103, rows.S0104, rows.S0105)
}
}

71
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S02.go

@ -0,0 +1,71 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_S02 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_S02SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_S02SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
S0201 string `xml:"S0201,attr"` // 读取flag属性 S0201
S0202 string `xml:"S0202,attr"` // 读取flag属性 S0202
S0203 string `xml:"S0203,attr"` // 读取flag属性 S0203
S0204 string `xml:"S0204,attr"` // 读取flag属性 S0204
S0205 string `xml:"S0205,attr"` // 读取flag属性 S0205
S0206 string `xml:"S0206,attr"` // 读取flag属性 S0206
S0207 string `xml:"S0207,attr"` // 读取flag属性 S0207
S0208 string `xml:"S0208,attr"` // 读取flag属性 S0208
S0209 string `xml:"S0209,attr"` // 读取flag属性 S0209
S0210 string `xml:"S0210,attr"` // 读取flag属性 S0210
S0211 string `xml:"S0211,attr"` // 读取flag属性 S0211
S0212 string `xml:"S0212,attr"` // 读取flag属性 S0212
S0213 string `xml:"S0213,attr"` // 读取flag属性 S0213
S0214 string `xml:"S0214,attr"` // 读取flag属性 S0214
S0215 string `xml:"S0215,attr"` // 读取flag属性 S0215
S0216 string `xml:"S0216,attr"` // 读取flag属性 S0216
S0217 string `xml:"S0217,attr"` // 读取flag属性 S0217
S0218 string `xml:"S0218,attr"` // 读取flag属性 S0218
S0219 string `xml:"S0219,attr"` // 读取flag属性 S0219
S0220 string `xml:"S0220,attr"` // 读取flag属性 S0220
S0221 string `xml:"S0221,attr"` // 读取flag属性 S0221
S0222 string `xml:"S0222,attr"` // 读取flag属性 S0222
S0223 string `xml:"S0223,attr"` // 读取flag属性 S0223
S0299 string `xml:"S0299,attr"` // 读取flag属性 S0299
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
S0224 string `xml:"S0224,attr"` // 读取flag属性 S0224
S0225 string `xml:"S0225,attr"` // 读取flag属性 S0225
S0226 string `xml:"S0226,attr"` // 读取flag属性 S0226
S0227 string `xml:"S0227,attr"` // 读取flag属性 S0227
S0228 string `xml:"S0228,attr"` // 读取flag属性 S0228
S0229 string `xml:"S0229,attr"` // 读取flag属性 S0229
}
func InsertM_S02(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_S02 (EUUID,S0215,S0216,S0217,S0218,S0219,S0220,S0221,S0222,S0223,S0299,ORDERBY,RNUM,S0224,S0225,S0226,S0227,S0228,S0214,S0213,SID,OUUID,RPT,TP,UNID,S0201,S0202,S0203,S0204,S0205,S0206,S0207,S0208,S0209,S0210,S0211,S0212,S0229) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_S02{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_S02...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.OUUID, rows.RPT, rows.TP, rows.UNID, rows.S0201, rows.S0202, rows.S0203, rows.S0204, rows.S0205, rows.S0206, rows.S0207, rows.S0208, rows.S0209, rows.S0210, rows.S0211, rows.S0212, rows.S0213, rows.S0214, rows.S0215, rows.S0216, rows.S0217, rows.S0218, rows.S0219, rows.S0220, rows.S0221, rows.S0222, rows.S0223, rows.S0299, rows.ORDERBY, rows.RNUM, rows.S0224, rows.S0225, rows.S0226, rows.S0227, rows.S0228, rows.S0229)
}
}

67
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S03.go

@ -0,0 +1,67 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_S03 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_S03SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_S03SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
S0301 string `xml:"S0301,attr"` // 读取flag属性 S0301
S0302 string `xml:"S0302,attr"` // 读取flag属性 S0302
S0303 string `xml:"S0303,attr"` // 读取flag属性 S0303
S0304 string `xml:"S0304,attr"` // 读取flag属性 S0304
S0305 string `xml:"S0305,attr"` // 读取flag属性 S0305
S0306 string `xml:"S0306,attr"` // 读取flag属性 S0306
S0307 string `xml:"S0307,attr"` // 读取flag属性 S0307
S0308 string `xml:"S0308,attr"` // 读取flag属性 S0308
S0309 string `xml:"S0309,attr"` // 读取flag属性 S0309
S0310 string `xml:"S0310,attr"` // 读取flag属性 S0310
S0311 string `xml:"S0311,attr"` // 读取flag属性 S0311
S0312 string `xml:"S0312,attr"` // 读取flag属性 S0312
S0313 string `xml:"S0313,attr"` // 读取flag属性 S0313
S0314 string `xml:"S0314,attr"` // 读取flag属性 S0314
S0315 string `xml:"S0315,attr"` // 读取flag属性 S0315
S0316 string `xml:"S0316,attr"` // 读取flag属性 S0316
S0317 string `xml:"S0317,attr"` // 读取flag属性 S0317
S0318 string `xml:"S0318,attr"` // 读取flag属性 S0318
S0319 string `xml:"S0319,attr"` // 读取flag属性 S0319
S0320 string `xml:"S0320,attr"` // 读取flag属性 S0320
S0321 string `xml:"S0321,attr"` // 读取flag属性 S0321
S0322 string `xml:"S0322,attr"` // 读取flag属性 S0322
S0323 string `xml:"S0323,attr"` // 读取flag属性 S0323
S0399 string `xml:"S0399,attr"` // 读取flag属性 S0399
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
S0324 string `xml:"S0324,attr"` // 读取flag属性 S0324
S0325 string `xml:"S0325,attr"` // 读取flag属性 S0325
}
func InsertM_S03(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_S03 (EUUID,S0313,S0314,S0315,S0316,S0317,S0318,S0319,S0320,S0321,S0322,S0323,S0399,ORDERBY,RNUM,S0324,S0312,S0311,SID,OUUID,RPT,TP,UNID,S0301,S0302,S0303,S0304,S0305,S0306,S0307,S0308,S0309,S0310,S0325) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_S03{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_S03...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.OUUID, rows.RPT, rows.TP, rows.UNID, rows.S0301, rows.S0302, rows.S0303, rows.S0304, rows.S0305, rows.S0306, rows.S0307, rows.S0308, rows.S0309, rows.S0310, rows.S0311, rows.S0312, rows.S0313, rows.S0314, rows.S0315, rows.S0316, rows.S0317, rows.S0318, rows.S0319, rows.S0320, rows.S0321, rows.S0322, rows.S0323, rows.S0399, rows.ORDERBY, rows.RNUM, rows.S0324, rows.S0325)
}
}

71
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S04.go

@ -0,0 +1,71 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_S04 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_S04SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_S04SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
S0401 string `xml:"S0401,attr"` // 读取flag属性 S0401
S0402 string `xml:"S0402,attr"` // 读取flag属性 S0402
S0403 string `xml:"S0403,attr"` // 读取flag属性 S0403
S0404 string `xml:"S0404,attr"` // 读取flag属性 S0404
S0405 string `xml:"S0405,attr"` // 读取flag属性 S0405
S0406 string `xml:"S0406,attr"` // 读取flag属性 S0406
S0407 string `xml:"S0407,attr"` // 读取flag属性 S0407
S0408 string `xml:"S0408,attr"` // 读取flag属性 S0408
S0409 string `xml:"S0409,attr"` // 读取flag属性 S0409
S0410 string `xml:"S0410,attr"` // 读取flag属性 S0410
S0411 string `xml:"S0411,attr"` // 读取flag属性 S0411
S0412 string `xml:"S0412,attr"` // 读取flag属性 S0412
S0413 string `xml:"S0413,attr"` // 读取flag属性 S0413
S0414 string `xml:"S0414,attr"` // 读取flag属性 S0414
S0415 string `xml:"S0415,attr"` // 读取flag属性 S0415
S0416 string `xml:"S0416,attr"` // 读取flag属性 S0416
S0417 string `xml:"S0417,attr"` // 读取flag属性 S0417
S0418 string `xml:"S0418,attr"` // 读取flag属性 S0418
S0419 string `xml:"S0419,attr"` // 读取flag属性 S0419
S0420 string `xml:"S0420,attr"` // 读取flag属性 S0420
S0421 string `xml:"S0421,attr"` // 读取flag属性 S0421
S0422 string `xml:"S0422,attr"` // 读取flag属性 S0422
S0423 string `xml:"S0423,attr"` // 读取flag属性 S0423
S0499 string `xml:"S0499,attr"` // 读取flag属性 S0499
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
S0424 string `xml:"S0424,attr"` // 读取flag属性 S0424
S0425 string `xml:"S0425,attr"` // 读取flag属性 S0425
S0426 string `xml:"S0426,attr"` // 读取flag属性 S0426
S0427 string `xml:"S0427,attr"` // 读取flag属性 S0427
S0428 string `xml:"S0428,attr"` // 读取flag属性 S0428
S0429 string `xml:"S0429,attr"` // 读取flag属性 S0429
}
func InsertM_S04(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_S04 (EUUID,S0415,S0416,S0417,S0418,S0419,S0420,S0421,S0422,S0423,S0499,ORDERBY,RNUM,S0424,S0425,S0426,S0427,S0428,S0414,S0413,SID,OUUID,RPT,TP,UNID,S0401,S0402,S0403,S0404,S0405,S0406,S0407,S0408,S0409,S0410,S0411,S0412,S0429) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_S04{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_S04...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.OUUID, rows.RPT, rows.TP, rows.UNID, rows.S0401, rows.S0402, rows.S0403, rows.S0404, rows.S0405, rows.S0406, rows.S0407, rows.S0408, rows.S0409, rows.S0410, rows.S0411, rows.S0412, rows.S0413, rows.S0414, rows.S0415, rows.S0416, rows.S0417, rows.S0418, rows.S0419, rows.S0420, rows.S0421, rows.S0422, rows.S0423, rows.S0499, rows.ORDERBY, rows.RNUM, rows.S0424, rows.S0425, rows.S0426, rows.S0427, rows.S0428, rows.S0429)
}
}

71
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S05.go

@ -0,0 +1,71 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_S05 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_S05SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_S05SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
S0501 string `xml:"S0501,attr"` // 读取flag属性 S0501
S0502 string `xml:"S0502,attr"` // 读取flag属性 S0502
S0503 string `xml:"S0503,attr"` // 读取flag属性 S0503
S0504 string `xml:"S0504,attr"` // 读取flag属性 S0504
S0505 string `xml:"S0505,attr"` // 读取flag属性 S0505
S0506 string `xml:"S0506,attr"` // 读取flag属性 S0506
S0507 string `xml:"S0507,attr"` // 读取flag属性 S0507
S0508 string `xml:"S0508,attr"` // 读取flag属性 S0508
S0509 string `xml:"S0509,attr"` // 读取flag属性 S0509
S0510 string `xml:"S0510,attr"` // 读取flag属性 S0510
S0511 string `xml:"S0511,attr"` // 读取flag属性 S0511
S0512 string `xml:"S0512,attr"` // 读取flag属性 S0512
S0513 string `xml:"S0513,attr"` // 读取flag属性 S0513
S0514 string `xml:"S0514,attr"` // 读取flag属性 S0514
S0515 string `xml:"S0515,attr"` // 读取flag属性 S0515
S0516 string `xml:"S0516,attr"` // 读取flag属性 S0516
S0517 string `xml:"S0517,attr"` // 读取flag属性 S0517
S0518 string `xml:"S0518,attr"` // 读取flag属性 S0518
S0519 string `xml:"S0519,attr"` // 读取flag属性 S0519
S0520 string `xml:"S0520,attr"` // 读取flag属性 S0520
S0521 string `xml:"S0521,attr"` // 读取flag属性 S0521
S0522 string `xml:"S0522,attr"` // 读取flag属性 S0522
S0523 string `xml:"S0523,attr"` // 读取flag属性 S0523
S0599 string `xml:"S0599,attr"` // 读取flag属性 S0599
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
S0524 string `xml:"S0524,attr"` // 读取flag属性 S0524
S0525 string `xml:"S0525,attr"` // 读取flag属性 S0525
S0526 string `xml:"S0526,attr"` // 读取flag属性 S0526
S0527 string `xml:"S0527,attr"` // 读取flag属性 S0527
S0528 string `xml:"S0528,attr"` // 读取flag属性 S0528
S0529 string `xml:"S0529,attr"` // 读取flag属性 S0529
}
func InsertM_S05(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_S05 (EUUID,S0515,S0516,S0517,S0518,S0519,S0520,S0521,S0522,S0523,S0599,ORDERBY,RNUM,S0524,S0525,S0526,S0527,S0528,S0514,S0513,SID,OUUID,RPT,TP,UNID,S0501,S0502,S0503,S0504,S0505,S0506,S0507,S0508,S0509,S0510,S0511,S0512,S0529) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_S05{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_S05...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.OUUID, rows.RPT, rows.TP, rows.UNID, rows.S0501, rows.S0502, rows.S0503, rows.S0504, rows.S0505, rows.S0506, rows.S0507, rows.S0508, rows.S0509, rows.S0510, rows.S0511, rows.S0512, rows.S0513, rows.S0514, rows.S0515, rows.S0516, rows.S0517, rows.S0518, rows.S0519, rows.S0520, rows.S0521, rows.S0522, rows.S0523, rows.S0599, rows.ORDERBY, rows.RNUM, rows.S0524, rows.S0525, rows.S0526, rows.S0527, rows.S0528, rows.S0529)
}
}

52
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S06.go

@ -0,0 +1,52 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_S06 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_S06SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_S06SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
S0601 string `xml:"S0601,attr"` // 读取flag属性 S0601
S0602 string `xml:"S0602,attr"` // 读取flag属性 S0602
S0603 string `xml:"S0603,attr"` // 读取flag属性 S0603
S0604 string `xml:"S0604,attr"` // 读取flag属性 S0604
S0605 string `xml:"S0605,attr"` // 读取flag属性 S0605
S0606 string `xml:"S0606,attr"` // 读取flag属性 S0606
S0607 string `xml:"S0607,attr"` // 读取flag属性 S0607
S0608 string `xml:"S0608,attr"` // 读取flag属性 S0608
S0609 string `xml:"S0609,attr"` // 读取flag属性 S0609
S0610 string `xml:"S0610,attr"` // 读取flag属性 S0610
S0699 string `xml:"S0699,attr"` // 读取flag属性 S0699
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
}
func InsertM_S06(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_S06 (EUUID,ORDERBY,S0699,S0610,S0609,S0608,S0607,S0606,S0605,S0604,S0603,S0602,S0601,UNID,TP,RPT,OUUID,SID,RNUM) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_S06{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_S06...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.OUUID, rows.RPT, rows.TP, rows.UNID, rows.S0601, rows.S0602, rows.S0603, rows.S0604, rows.S0605, rows.S0606, rows.S0607, rows.S0608, rows.S0609, rows.S0610, rows.S0699, rows.ORDERBY, rows.RNUM)
}
}

71
golang_learn/data_office/get_hzb_xml/go_to_hzbtj/hzbtj/M_S07.go

@ -0,0 +1,71 @@
package hzbtj
import (
"database/sql"
"encoding/xml"
_ "github.com/go-sql-driver/mysql"
)
type M_S07 struct {
XMLName xml.Name `xml:"xml"` // 指定最外层的标签为config
tab string `xml:"tab,attr"` // 读取flag属性 tab
year string `xml:"year,attr"` // 读取flag属性 year
Row []M_S07SRow `xml:"row"` // 读取receivers标签下的内容,以结构方式获取
}
type M_S07SRow struct {
EUUID string `xml:"EUUID,attr"` // 读取flag属性 EUUID
SID string `xml:"SID,attr"` // 读取flag属性 SID
OUUID string `xml:"OUUID,attr"` // 读取flag属性 OUUID
RPT string `xml:"RPT,attr"` // 读取flag属性 RPT
TP string `xml:"TP,attr"` // 读取flag属性 TP
UNID string `xml:"UNID,attr"` // 读取flag属性 UNID
S0701 string `xml:"S0701,attr"` // 读取flag属性 S0701
S0702 string `xml:"S0702,attr"` // 读取flag属性 S0702
S0703 string `xml:"S0703,attr"` // 读取flag属性 S0703
S0704 string `xml:"S0704,attr"` // 读取flag属性 S0704
S0705 string `xml:"S0705,attr"` // 读取flag属性 S0705
S0706 string `xml:"S0706,attr"` // 读取flag属性 S0706
S0707 string `xml:"S0707,attr"` // 读取flag属性 S0707
S0708 string `xml:"S0708,attr"` // 读取flag属性 S0708
S0709 string `xml:"S0709,attr"` // 读取flag属性 S0709
S0710 string `xml:"S0710,attr"` // 读取flag属性 S0710
S0711 string `xml:"S0711,attr"` // 读取flag属性 S0711
S0712 string `xml:"S0712,attr"` // 读取flag属性 S0712
S0713 string `xml:"S0713,attr"` // 读取flag属性 S0713
S0714 string `xml:"S0714,attr"` // 读取flag属性 S0714
S0715 string `xml:"S0715,attr"` // 读取flag属性 S0715
S0716 string `xml:"S0716,attr"` // 读取flag属性 S0716
S0717 string `xml:"S0717,attr"` // 读取flag属性 S0717
S0718 string `xml:"S0718,attr"` // 读取flag属性 S0718
S0719 string `xml:"S0719,attr"` // 读取flag属性 S0719
S0720 string `xml:"S0720,attr"` // 读取flag属性 S0720
S0721 string `xml:"S0721,attr"` // 读取flag属性 S0721
S0722 string `xml:"S0722,attr"` // 读取flag属性 S0722
S0723 string `xml:"S0723,attr"` // 读取flag属性 S0723
S0799 string `xml:"S0799,attr"` // 读取flag属性 S0799
ORDERBY string `xml:"ORDERBY,attr"` // 读取flag属性 ORDERBY
RNUM string `xml:"RNUM,attr"` // 读取flag属性 RNUM
S0724 string `xml:"S0724,attr"` // 读取flag属性 S0724
S0725 string `xml:"S0725,attr"` // 读取flag属性 S0725
S0726 string `xml:"S0726,attr"` // 读取flag属性 S0726
S0727 string `xml:"S0727,attr"` // 读取flag属性 S0727
S0728 string `xml:"S0728,attr"` // 读取flag属性 S0728
S0729 string `xml:"S0729,attr"` // 读取flag属性 S0729
}
func InsertM_S07(path, fileName string, db *sql.DB) {
var sqlStr string = "INSERT INTO M_S07 (EUUID,S0715,S0716,S0717,S0718,S0719,S0720,S0721,S0722,S0723,S0799,ORDERBY,RNUM,S0724,S0725,S0726,S0727,S0728,S0714,S0713,SID,OUUID,RPT,TP,UNID,S0701,S0702,S0703,S0704,S0705,S0706,S0707,S0708,S0709,S0710,S0711,S0712,S0729) VALUE (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
pathStr := path + fileName
v := M_S07{}
GetObjListMap(pathStr, &v)
stmt, err := db.Prepare(sqlStr)
if err != nil {
return
}
println("开始执行M_S07...")
for _, rows := range v.Row {
stmt.Exec(rows.EUUID, rows.SID, rows.OUUID, rows.RPT, rows.TP, rows.UNID, rows.S0701, rows.S0702, rows.S0703, rows.S0704, rows.S0705, rows.S0706, rows.S0707, rows.S0708, rows.S0709, rows.S0710, rows.S0711, rows.S0712, rows.S0713, rows.S0714, rows.S0715, rows.S0716, rows.S0717, rows.S0718, rows.S0719, rows.S0720, rows.S0721, rows.S0722, rows.S0723, rows.S0799, rows.ORDERBY, rows.RNUM, rows.S0724, rows.S0725, rows.S0726, rows.S0727, rows.S0728, rows.S0729)
}
}
Loading…
Cancel
Save