这篇文章主要围绕通用数据库导出程序，支持mysql和mssql展开，旨在为您提供一份详细的参考资料。我们将全面介绍通用数据库导出程序，支持mysql和mssql，同时也会为您带来1.mssql和mys

这篇文章主要围绕通用数据库导出程序，支持mysql和mssql展开，旨在为您提供一份详细的参考资料。我们将全面介绍通用数据库导出程序，支持mysql和mssql，同时也会为您带来1.mssql和mysql sql如何调优？、1.MYSQL中将数据库导出成SQL文件、Aorm又进步了，目前已支持MySQL,MSSQL,Postgres,Sqlite3，并且支持子查询、C# 多数据库组件包，支持 MSSQL+Oracle+MySQL + 用户操作手册 | C/S 开发框架的实用方法。

本文目录一览：

• 通用数据库导出程序，支持mysql和mssql
• 1.mssql和mysql sql如何调优？
• 1.MYSQL中将数据库导出成SQL文件
• Aorm又进步了，目前已支持MySQL,MSSQL,Postgres,Sqlite3，并且支持子查询
• C# 多数据库组件包，支持 MSSQL+Oracle+MySQL + 用户操作手册 | C/S 开发框架

通用数据库导出程序，支持mysql和mssql

通用数据库导出程序，支持mysql和mssql，暂不支持oracle

sql写到配置文件中，当前所有的where语句都是写到q中的.

例如： http://localhost:56780/?site=abc&q=where+dept%3D%27%E7%BB%8F%E6%B5%8E%E7%AE%A1%E7%90%86%E5%AD%A6%E9%99%A2%27

其中q是where dept=''经济管理学院''

计算方式用到php中的urlencode("where dept=''经济管理学院''")，这种方式解决了where后面的参数变化问题

备注： sql server2008 R2 需要安装一个补丁，否则无法登录SQL Server 2008 and 2008 R2 engine cannot handle login records when SSL encryption is not disabled. To fix SQL Server 2008 R2 issue, install SQL Server 2008 R2 Service Pack 2. To fix SQL Server 2008 issue, install Microsoft SQL Server 2008 Service Pack 3 and Cumulative update package 3 for SQL Server 2008 SP3. More information: http://support.microsoft.com/kb/2653857

[Query]
#mysql  sqlserver orcal 三个
Sql_type=sqlserver
; Sql_conn=proxy:proxy321@tcp(localhost:3306)/v358web
Sql_conn=sqlserver://sa:mypass@localhost?database=master&connection+timeout=30
#sql语句参数，
Sql=`SELECT code,code_desc,type FROM setting `
# http://.../index.php?req1=a&req2=b&req=3
# 对于不同的参数，有不同的类型
Debug=1 
[Params]
-: vn
[AllowIP]
127.0.0.2 = true
127.0.0.21 = true
127.0.0.23 = true
127.0.0.24 = true
127.0.0.1 = true
# sample of connection sql
#proxy:proxy321@tcp(localhost:3306)/v358web
#sqlserver://username:password@host/instance?param1=value&param2=value
#sqlserver://username:password@host:port?param1=value&param2=value

下面是代码，把所有的数据导出，当前很建议，后面给json加上长度、成功/失败提示。

//通用的导出程序，支持mysql/mssql
// 使用说明 https://my.oschina.net/jianhui1980/blog/3112760
/* 关于安全的几个原则：
// 1、限制ip
// 2、验证双方约定加密字符串，EncodeKey ，md5(EncodeKey+date)
// 3、必须只能select，中间不能有 分号'';''
// 4、考虑性能，限制访问频率
// 5、必须数据库的只读账号
// 6、记录sql，时间、ip、sql三个

CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o  export_all.exe export_all.go
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o  export_all_amd_linux export_all.go
go build -o  export_all_amd_darwin export_all.go

php -r "echo urlencode(''where dept=\''经济管理学院\'''');"
*/
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	//	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"path"
	_ "strconv"
	"strings"
	"time"

	_ "github.com/denisenkom/go-mssqldb"
	_ "github.com/fatih/color"
	"github.com/go-ini/ini"
	_ "github.com/go-sql-driver/mysql"
)

func main() {

	http.HandleFunc("/", handler)
	log.Fatal(http.ListenAndServe("127.0.0.1:56780", nil))

}

func handler(w http.ResponseWriter, r *http.Request) {

	site := r.FormValue("site")
	qc := NewQueryConfig(site, r)
	if r.FormValue("db") == "1" {
		qc.Debug = true
	}
	if !qc.checkIP() {
		fmt.Fprintf(w, "{\"rs\":\"error\",\"msg\":\"IP不在允许访问范围内！\"}", r.RemoteAddr)
		return
	}
	qc.initDB()
	//
	data, err := qc.runDB()
	if err != nil {
		log.Println("data error: ", err)
	}
	log.Println("qc;", qc)
	fmt.Fprintf(w, "Hi there, I love %s!"+site+": "+data, r.URL.Path[1:])
	if err == nil {
		fmt.Fprintf(w, "ccc:"+data)
	}
	defer qc.db.Close()

}

type QueryConfig struct {
	db        *sql.DB
	req       *http.Request
	ip        string
	Sql_type  string
	Sql_conn  string
	Sql       string //取消掉，直接由client来提交sql
	EncodeKey string //双方约定加密字符串
	Parms     map[string]string
	AllowIP   map[string]string
	Debug     bool
}

func NewQueryConfig(file_name string, req *http.Request) *QueryConfig {

	wd, _ := os.Getwd()
	cfg_file := path.Join(wd, file_name+".ini")

	//	log.Println(" cfg_file2:", cfg_file)
	// cfg, err := ini.Load(cfg_file)
	cfg, err := ini.LoadSources(ini.LoadOptions{AllowBooleanKeys: true}, cfg_file)
	if err != nil {
		log.Println(cfg_file + " : " + err.Error())
		//		io.WriteString(w, "解析日志发生错误："+cfg_file)
		//		rs := "解析日志发生错误：" + cfg_file
		return nil
	}

	query_config := new(QueryConfig)
	query_config.req = req
	err2 := cfg.Section("Query").MapTo(query_config)
	if err2 != nil {
		log.Println("cfg Query  错误：;", cfg_file, "  \nerror: ", err2.Error())
	}
	if query_config.Debug {
		log.Println(" cfg_file:", cfg_file)
		log.Println("query_config:", query_config)
	}
	query_config.Parms = cfg.Section("Params").KeysHash()
	query_config.AllowIP = cfg.Section("AllowIP").KeysHash()
	// query_config.openDB()
	return query_config
}

func (qc *QueryConfig) checkIP() bool {
	ip_pos := strings.Index(qc.req.RemoteAddr, ":")
	if ip_pos > 0 {
		ip := qc.req.RemoteAddr[0:ip_pos]
		qc.ip = ip
		if qc.Debug {
			log.Println("ip:", ip)
			log.Println(qc.AllowIP)
		}
		_, found := qc.AllowIP[ip]
		if found {
			if qc.Debug {
				log.Println("succ: ", qc.AllowIP)
			}
			return true
		} else {
			if qc.Debug {
				log.Println("error: ", qc.AllowIP)
			}
		}
	}

	return false
}
func (qc *QueryConfig) getDB() *sql.DB {
	return qc.db
}
func (qc *QueryConfig) initDB() {
	switch {
	case qc.Sql_type == "mysql":
		db, err := sql.Open("mysql", qc.Sql_conn)
		if err != nil {
			fmt.Println("sql.Open:", err)
			return
		}
		qc.db = db
	case qc.Sql_type == "sqlserver":
		//		log.Println("open sqlserver")
		db, err := sql.Open("sqlserver", qc.Sql_conn)
		db.SetConnMaxLifetime(10 * time.Minute)
		if err != nil {
			fmt.Println("sql.Open:", err)
			return
		}
		qc.db = db

		//	case sql_type == "oracle":
	}
}

func (qc *QueryConfig) runDB() (string, error) {

	theCase := "lower" // "lower", "upper", "camel" or the orignal case if this is anything other than these three
	log.Println("rundb1 : ", qc.req.URL.Query())

	// 下面是示例代码，所以不要删除
	// headers []string, data [][]string, error
	//	headers, data, _ := QueryDbToArray(qc.db, theCase, "SELECT code,code_desc,type FROM setting LIMIT ?,?", 0, 3)
	//	fmt.Println(headers)
	//	// ["id","name"]
	//	fmt.Println(data)
	// [["0","Alicia"],["1","Brian"],["2","Chloe"]]
	// data []map[string]string, error

	query := qc.req.URL.Query()

	if len(query) > 0 {
		log.Println("rundb2 : ", query)
		decodeurl, err := url.QueryUnescape(query["q"][0])
		if qc.Debug {
			log.Println("rundb3 : ", decodeurl)
		}
		if err != nil {
			fmt.Println("decodeurl error: ", err)
		}
		if qc.Debug {
			fmt.Println("before Export:.....", qc.Sql+decodeurl)
		}
		return QueryDbToMapJSON(qc.getDB(), theCase, qc.Sql+decodeurl)
	}
	return QueryDbToMapJSON(qc.getDB(), theCase, qc.Sql)
	//	return data2, err
	// [{"id":"0","name":"Alicia"},{"id":"1","name":"Brian"},{"id":"2","name":"Chloe"}]

}

// QueryDbToArrayJSON - run the sql and return a a JSON string of array
func QueryDbToArrayJSON(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) (string, error) {
	headers, data, err := QueryDbToArray(db, theCase, sqlStatement, sqlParams...)
	result := map[string]interface{}{
		"headers": headers,
		"data":    data,
	}
	jsonString, err := json.Marshal(result)
	return string(jsonString), err
}

// QueryDbToMapJSON - run the sql and return a JSON string of array of objects.
func QueryDbToMapJSON(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) (string, error) {
	//	log.Println("QueryDbToMapJSON in 1")
	data, err := QueryDbToMap(db, theCase, sqlStatement, sqlParams...)
	jsonString, err := json.Marshal(data)
	//	log.Println("QueryDbToMapJSON in 2", err, ": jsonString: ", jsonString)
	return string(jsonString), err
}

// QueryDbToArray - headers, data, error
func QueryDbToArray(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) ([]string, [][]string, error) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	data := [][]string{}
	headers := []string{}
	rows, err := db.Query(sqlStatement, sqlParams...)
	if err != nil {
		fmt.Println("Error executing: ", sqlStatement)
		return headers, data, err
	}
	cols, _ := rows.Columns()
	if theCase == "lower" {
		colsLower := make([]string, len(cols))
		for i, v := range cols {
			colsLower[i] = strings.ToLower(v)
		}
		headers = colsLower
	} else if theCase == "upper" {
		colsUpper := make([]string, len(cols))
		for i, v := range cols {
			colsUpper[i] = strings.ToUpper(v)
		}
		headers = colsUpper
	} else if theCase == "camel" {
		colsCamel := make([]string, len(cols))
		for i, v := range cols {
			colsCamel[i] = toCamel(v)
		}
		headers = colsCamel
	} else {
		headers = cols
	}

	rawResult := make([][]byte, len(cols))

	dest := make([]interface{}, len(cols)) // A temporary interface{} slice
	for i := range rawResult {
		dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
	}

	for rows.Next() {
		result := make([]string, len(cols))
		rows.Scan(dest...)
		for i, raw := range rawResult {
			if raw == nil {
				result[i] = ""
			} else {
				result[i] = string(raw)
			}
		}
		data = append(data, result)
	}
	return headers, data, nil
}

// QueryTxToArray - headers, data, error
func QueryTxToArray(tx *sql.Tx, theCase string, sqlStatement string, sqlParams ...interface{}) ([]string, [][]string, error) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	data := [][]string{}
	headers := []string{}
	rows, err := tx.Query(sqlStatement, sqlParams...)
	if err != nil {
		fmt.Println("Error executing: ", sqlStatement)
		return headers, data, err
	}
	cols, _ := rows.Columns()
	if theCase == "lower" {
		colsLower := make([]string, len(cols))
		for i, v := range cols {
			colsLower[i] = strings.ToLower(v)
		}
		headers = colsLower
	} else if theCase == "upper" {
		colsUpper := make([]string, len(cols))
		for i, v := range cols {
			colsUpper[i] = strings.ToUpper(v)
		}
		headers = colsUpper
	} else if theCase == "camel" {
		colsCamel := make([]string, len(cols))
		for i, v := range cols {
			colsCamel[i] = toCamel(v)
		}
		headers = colsCamel
	} else {
		headers = cols
	}

	rawResult := make([][]byte, len(cols))

	dest := make([]interface{}, len(cols)) // A temporary interface{} slice
	for i := range rawResult {
		dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
	}

	for rows.Next() {
		result := make([]string, len(cols))
		rows.Scan(dest...)
		for i, raw := range rawResult {
			if raw == nil {
				result[i] = ""
			} else {
				result[i] = string(raw)
			}
		}
		data = append(data, result)
	}
	return headers, data, nil
}

// QueryDbToMap - run sql and return an array of maps
func QueryDbToMap(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) ([]map[string]string, error) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	results := []map[string]string{}
	rows, err := db.Query(sqlStatement, sqlParams...)
	if err != nil {
		fmt.Println("Error executing run: ", sqlStatement, err)
		return results, err
	}
	//	log.Println("rows: ", rows)
	cols, _ := rows.Columns()
	colsLower := make([]string, len(cols))
	colsCamel := make([]string, len(cols))

	if theCase == "lower" {
		for i, v := range cols {
			colsLower[i] = strings.ToLower(v)
		}
	} else if theCase == "upper" {
		for i, v := range cols {
			cols[i] = strings.ToUpper(v)
		}
	} else if theCase == "camel" {
		for i, v := range cols {
			colsCamel[i] = toCamel(v)
		}
	}

	rawResult := make([][]byte, len(cols))

	dest := make([]interface{}, len(cols)) // A temporary interface{} slice
	for i := range rawResult {
		dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
	}

	for rows.Next() {
		result := make(map[string]string, len(cols))
		rows.Scan(dest...)
		for i, raw := range rawResult {
			if raw == nil {
				if theCase == "lower" {
					result[colsLower[i]] = ""
				} else if theCase == "upper" {
					result[cols[i]] = ""
				} else if theCase == "camel" {
					result[colsCamel[i]] = ""
				} else {
					result[cols[i]] = ""
				}
			} else {
				if theCase == "lower" {
					result[colsLower[i]] = string(raw)
				} else if theCase == "upper" {
					result[cols[i]] = string(raw)
				} else if theCase == "camel" {
					result[colsCamel[i]] = string(raw)
				} else {
					result[cols[i]] = string(raw)
				}
			}
		}
		results = append(results, result)
	}
	return results, nil
}

// QueryTxToMap - run sql and return an array of maps
func QueryTxToMap(tx *sql.Tx, theCase string, sqlStatement string, sqlParams ...interface{}) ([]map[string]string, error) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	results := []map[string]string{}
	rows, err := tx.Query(sqlStatement, sqlParams...)
	if err != nil {
		fmt.Println("Error executing: ", sqlStatement)
		return results, err
	}
	cols, _ := rows.Columns()
	colsLower := make([]string, len(cols))
	colsCamel := make([]string, len(cols))

	if theCase == "lower" {
		for i, v := range cols {
			colsLower[i] = strings.ToLower(v)
		}
	} else if theCase == "upper" {
		for i, v := range cols {
			cols[i] = strings.ToUpper(v)
		}
	} else if theCase == "camel" {
		for i, v := range cols {
			colsCamel[i] = toCamel(v)
		}
	}

	rawResult := make([][]byte, len(cols))

	dest := make([]interface{}, len(cols)) // A temporary interface{} slice
	for i := range rawResult {
		dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
	}

	for rows.Next() {
		result := make(map[string]string, len(cols))
		rows.Scan(dest...)
		for i, raw := range rawResult {
			if raw == nil {
				if theCase == "lower" {
					result[colsLower[i]] = ""
				} else if theCase == "upper" {
					result[cols[i]] = ""
				} else if theCase == "camel" {
					result[colsCamel[i]] = ""
				} else {
					result[cols[i]] = ""
				}
			} else {
				if theCase == "lower" {
					result[colsLower[i]] = string(raw)
				} else if theCase == "upper" {
					result[cols[i]] = string(raw)
				} else if theCase == "camel" {
					result[colsCamel[i]] = string(raw)
				} else {
					result[cols[i]] = string(raw)
				}
			}
		}
		results = append(results, result)
	}
	return results, nil
}

// ExecDb - run the sql and returns rows affected.
func ExecDb(db *sql.DB, sqlStatement string, sqlParams ...interface{}) (int64, error) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	result, err := db.Exec(sqlStatement, sqlParams...)
	if err != nil {
		fmt.Println("Error executing: ", sqlStatement)
		fmt.Println(err)
		return 0, err
	}
	return result.RowsAffected()
}

// ExecTx - run the sql and returns rows affected.
func ExecTx(tx *sql.Tx, sqlStatement string, sqlParams ...interface{}) (int64, error) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	result, err := tx.Exec(sqlStatement, sqlParams...)
	if err != nil {
		fmt.Println("Error executing: ", sqlStatement)
		fmt.Println(err)
		return 0, err
	}
	return result.RowsAffected()
}

func toCamel(s string) (ret string) {
	s = strings.ToLower(s)
	a := strings.Split(s, "_")
	for i, v := range a {
		if i == 0 {
			ret += v
		} else {
			f := strings.ToUpper(string(v[0]))
			n := string(v[1:])
			ret += fmt.Sprint(f, n)
		}
	}
	return
}

1.mssql和mysql sql如何调优？

mssql是指微软的SQL Server数据库服务器。

mssql常见的调优方法主要分为两类，

（1）代码优化，代码优化，我搜集常用到的有以下几点：

　　1.避免使用select *  语句

　　2.避免关联不需要的表

　　3.能用UNION  ALL就不要用UNION

　　4.避免使用!=或＜＞、IS NULL或IS NOT NULL、IN ，NOT IN等这样的操作符,因为这会使系统无法使用索引,而只能直接搜索表中的数据

　　5.能用DISTINCT的就不用GROUP BY

　　6.能够用BETWEEN的就不要用IN

　　7.尽量避免在WHERE子句中对字段进行函数或表达式操作，这将导致引擎放弃使用索引而进行全表扫描

（2）数据库优化

　　1.加大内存

　　2.在常用字段中加入索引，要视情况而定，如果该字段修改操作比较频繁，会导致查询很慢

　　3.分库分表

mysql是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，目前属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一

mysql常见的调优方法主要有以下几点，

　　1.选择合适的存储引擎：mysql默认选择的是 InnoDB引擎， MyISAM和InnoDB区别：MyISAM 比 InnoDB 速度快，MyISAM 不支持事务

　　2.保证从内存中读取数据，将数据保存在内存中，设置足够大innodb_buffer_pool_size

　　3.顶起优化重建数据库

　　4.降低磁盘写入操作

　　5.提高磁盘读写速度

　　6.充分创建索引

1.MYSQL中将数据库导出成SQL文件

1.MYSQL中将数据库导出成SQL文件

其实很简单的，就是一条语句就可以了，首先我们打开cmd，不用进MySQL指令界面，直接按照下列格式将导出语句敲进去，然后再输入密码即可了：

mysqldump -h[主机所在IP] -u[用户名] -p [要导出的数据库]>[导出的路径//[文件名].sql]

实例:

>mysqldump -h 192.168.2.184 -u root -p dxq_oaxt > d:\dxq_oaxt.sql

好吧，直接这样看可能有点抽象，我们来举个例子，目前我的mysql中有一个数据库bookinfodb，现在我要将它导出并且保存到D盘中。

这个时候我们再到D盘目录下，我们就可以看到多了一个bookinfodb.sql文件了

2.从SQL文件中导入数据到MYSQL中

1>首先，我们应该在cmd中进入mysql指令界面中，格式很简单 ，就是mysql -u[用户名] -h[主机所在地址，默认不写是localhost] -p 然后输入密码即可

2>使用CREATE  DATRABSE [数据库名字]创建一个数据库，然后使用use [数据库名]选择要使用的数据库

3>直接使用source [所在的路径//*.sql] 将SQL文件进行导入

接下来就会输出一大串的Query OK之类的信息了。

实例:

>mysql -u root -h 192.168.2.184 -p

>输入密码

>use dxq_oaxt;

>source d:/dxq_oaxt.sql;

或者

>mysql -h 192.168.1.224 -P 3306 -u root -p test<c:\test.sql 

3、把查询的结果存入一个表中

insert into tableB select * from tableA;

4、把查询的结果写入文件

进入mysql命令行，mysql > select * from tableA INTO OUTFILE  ''/home/out.txt'';

Aorm又进步了，目前已支持MySQL,MSSQL,Postgres,Sqlite3，并且支持子查询

hi，各位golang的朋友，我很高兴的告诉你们，Aorm又进步了。

Aorm是什么

Aorm是一个基于go语言的数据库操作库，可以帮助你更方便的进行数据库操作。

它最大的特点是支持空值查询和更新，以及支持sql的链式操作，特别类似于php相关的orm操作

这里是之前发过的一个文档
想早点下班？试试Aorm库吧，更方便的进行Go数据库操作 - 掘金 (juejin.cn)

这是具体的项目地址
tangpanqing/aorm: Operate Database So Easy For GoLang Developer (github.com)

在最近的一个星期左右，我将它进行了升级。

之前只支持MySQL，目前已经支持MySQL, MSSQL, Postgres, Sqlite3等四大数据库

之前不支持子查询，目前已经支持

示例

一般情况下的写入

如果你使用MySQL,Sqlite3 数据库，可以直接使用如下的代码，来进行一次插入

id, errInsert := aorm.Use(db).Debug(true).Insert(&Person{
    Name:       null.StringFrom("Alice"),
    Sex:        null.BoolFrom(false),
    Age:        null.IntFrom(18),
    Type:       null.IntFrom(0),
    CreateTime: null.TimeFrom(time.Now()),
    Money:      null.FloatFrom(100.15),
    Test:       null.FloatFrom(200.15987654321987654321),
})
if errInsert != nil {
    fmt.Println(errInsert)
}
fmt.Println(id)

它产生的sql如下

INSERT INTO person (name,sex,age,type,create_time,money,test) VALUES (?,?,?,?,?,?,?)
Alice false 18 0 2022-12-07 10:10:26.1450773 +0800 CST m=+0.031808801 100.15 200.15987654321987

MSSQL与Postgres的特殊性

如果你使用MSSQL,Postgres 数据库，需要增加一个Driver操作，以明确的告诉Aorm，这里是MSSQL或者Postgres，Aorm会对sql做一些修改，例如

id, errInsert := aorm.Use(db).Debug(true).Driver("mssql").Insert(&Person{
    ....
})

它产生的sql如下

INSERT INTO person (name,sex,age,type,create_time,money,test) VALUES (?,?,?,?,?,?,?); select ID = convert(bigint, SCOPE_IDENTITY())
Alice false 18 0 2022-12-07 10:10:26.1450773 +0800 CST m=+0.031808801 100.15 200.15987654321987

你可能已经注意到，生成的sql里，加上了

select ID = convert(bigint, SCOPE_IDENTITY())

这是因为mssql默认情况下，并不会返回最后插入的记录id，只有加上这一句sql，进行一次查询才能得到

另外Postgres也有类似的情况，只不过它加的sql代码是

returning id

支持子查询

子查询是非常重要的功能，可以极大的方便查询，目前aorm已经可以支持

将子查询用在字段上

var listByFiled []PersonWithArticleCount

sub := aorm.Sub().Table("article").SelectCount("id", "article_count_tem").WhereRaw("person_id", "=person.id")

err := aorm.Use(db).Debug(false).
   Driver(driver).
   SelectExp(&sub, "article_count").
   Select("*").
   Where(&Person{Age: null.IntFrom(18)}).
   GetMany(&listByFiled)

if err != nil {
   panic(driver + " testSelectWithSub " + "found err:" + err.Error())
}

你可能已经注意到

sub := aorm.Sub().Table("article").SelectCount("id", "article_count_tem").WhereRaw("person_id", "=person.id")

这里定义了一个子查询，它此时并没有查询数据库哦，然后将他作为参数使用

   SelectExp(&sub, "article_count").

意思很明显，上述子查询的结果，将被重命名一个新的字段 article_count，最终生成的sql为

SELECT *,(SELECT count(id) AS article_count_tem FROM article WHERE person_id=person.id) AS article_count FROM person WHERE age = ?
18

将子查询用在查询条件上

var listByFiled []Person

sub := aorm.Sub().Table("article").Select("person_id").GroupBy("person_id").HavingGt("count(person_id)", 0)

err := aorm.Use(db).Debug(false).
   Table("person").
   Driver(driver).
   WhereIn("id", &sub).
   GetMany(&listByFiled)

if err != nil {
   panic(driver + " testWhereWithSub " + "found err:" + err.Error())
}

如你所见

sub := aorm.Sub().Table("article").Select("person_id").GroupBy("person_id").HavingGt("count(person_id)", 0)

这里定义了一个子查询，它在如下的代码块被使用

   WhereIn("id", &sub).

意思很明显，上述子查询的结果，将被用作where的一个条件，它产生的sql如下

SELECT * FROM person WHERE id IN (SELECT person_id FROM article GROUP BY person_id Having count(person_id) > ?)
0

总结

支持了更多的数据库，Aorm拓展了更多的应用范围
支持了子查询，Aorm更强大了

项目地址
tangpanqing/aorm: Operate Database So Easy For GoLang Developer (github.com)

给个 ⭐ 吧，如果这个项目帮助到你

C# 多数据库组件包，支持 MSSQL+Oracle+MySQL + 用户操作手册 | C/S 开发框架

  C# 多数据库组件包支持 MSSQL+Oracle+MySQL + 用户操作手册 | C/S 框架网

我们在开发软件过程中，特别是基于数据管理应用相关的系统，一般采用一种数据库，如 Microsoft SQL Server，超大型系统有的使用 Oracle，部分 Web 系统采用开源的 MySQL 等，由于各种业务场景以及用户需求，促使我们的数据库系统部署在不同类型的数据库服务器上。若开发的系统能支持多种数据库的快速切换，可以为我们减少很多烦恼，同时提高系统的适应性、兼容性以及可扩展性。

关于通用数据库导出程序，支持mysql和mssql的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于1.mssql和mysql sql如何调优？、1.MYSQL中将数据库导出成SQL文件、Aorm又进步了，目前已支持MySQL,MSSQL,Postgres,Sqlite3，并且支持子查询、C# 多数据库组件包，支持 MSSQL+Oracle+MySQL + 用户操作手册 | C/S 开发框架的相关信息，请在本站寻找。

本文标签：

• MySQL
• MSSQL
• Database_Export
• Programming_Tools