数据库 on 月盾的博客

Elasticsearch批量insert和批量upsert

Wed, 28 Sep 2022 14:00:43 +0800

golang版本的elasticsearch批量插入和批量更新方法如下：

package main

import (
  "github.com/elastic/go-elasticsearch/v8"
  "github.com/elastic/go-elasticsearch/v8/esutil"
)
func main()  {
  list:=make(User, 0)
  bulkES(list)
}

func bulkES(list []User) error {
	indexer, err := esutil.NewBulkIndexer(esutil.BulkIndexerConfig{
		Index:  "search-user",
		Client: ES,
	})
	if err != nil {
		return err
	}
	for _, v := range list {
		data, err := json.Marshal(v)
		if err != nil {
			return err
		}
		err = indexer.Add(
			context.Background(),
			esutil.BulkIndexerItem{
				Action: "index",
				Body:   bytes.NewReader(data),
			},
		)
		if err != nil {
			return err
		}
	}
	indexer.Close(context.Background())
	return nil
}

最简单版的代码整体上就是如此，但需要注意，该代码不适用于生产环境，只能作为测试。主要原因是indexer实例不能多次实例化，所以上面所示代码是一个函数，这个函数是不能多次调用，因为多次进行indexer实例化了，很快就会内存溢出崩溃掉。

正确的使用方式是在init函数或者连接elasticsearch后进行实例化一次，作为全局变量在后续使用，大概是这样：

package main

import (
  "github.com/elastic/go-elasticsearch/v8"
  "github.com/elastic/go-elasticsearch/v8/esutil"
)
var userindexer esutil.BulkIndexer

func init() {
  indexer, err := esutil.NewBulkIndexer(esutil.BulkIndexerConfig{
		Index:  "search-user",
		Client: ES,
	})
  if err != nil {
		return err
	}
  userindexer = indexer
}
func bulkES(list []User) error {
	for _, v := range list {
		data, err := json.Marshal(v)
		if err != nil {
			return err
		}
		err = userindexer.Add(
			context.Background(),
			esutil.BulkIndexerItem{
				Action: "index",
				Body:   bytes.NewReader(data),
			},
		)
		if err != nil {
			return err
		}
	}
	// userindexer.Close(context.Background())
	return nil
}

注意： 代码只做演示使用，不保证能正确运行。

go mongo-driver动态条件

Fri, 19 Jun 2020 07:57:09 +0000

在go mongo中查询是使用的是bson.M类型的条件，但是直接使用时无法动态添加条件，只能初始化赋值，bson.M其实就是map类型，只能使用someMap[“someKey”]=“someValue” 的形式添加，这样的话只能是用if判断字段的值来决定是否添加map key/value，写起来比较繁琐。还有一种是利用结构体转换为bson.M来实现。

//构造一个查询结构体
search := User{
		ID: id,
		Name: name,
		Age: age,
	}
//构造一个条件变量
	condition := bson.M{}
	//将结构体转为字节数组，userInfo中的字段根据需要设置值，需要保证没有值时不会有默认值出现
	userbyte, err := bson.Marshal(search)
	if err != nil {
		return user, err
	}
	//将字节码转为bson.M类型
	bson.Unmarshal(userbyte, &condition)
	log.Println(condition)
	if err = this.mongo.Collection("user").FindOne(context.TODO(),
		condition).Decode(&user); err != nil {
		return user, err
	}

以上基本就实现了动态条件查询的效果，其中：

search := User{
		ID: id,
		Name: name,
		Age: age,
	}

search结构中的字段可能值为空，假设在前端并未传递age字段，那么最终condition=map[id:xxx,name:xxx]，并不会出现age:0这个的字段，有效避免了零值情况。

免费的mongodb集群

Tue, 07 Apr 2020 03:28:06 +0000

mongodb提供了免费的mongodb集群可用于学习使用 https://www.mongodb.com/cloud 并且有3个节点

mongodb Atlas免费集群存储空间为512M，这对于个人项目来说足够使用（本博客运行6年使用空间8M）。

本地客户端连接mongo Atlas

复制了连接字符串后直接粘贴到客户端中，替换,点击From SRV,会自动拉取集群配置，点击Test测试连接是否成功。

mongodb创建新数据库和创建用户

Sat, 04 Apr 2020 01:58:04 +0000

使用mongodb数据库时有这样的场景，使用可视化工具登陆了某个数据库blogs,然后又创建了数据库website,给website数据库添加用户hp_website

db.createUser( {user: "hp_website",pwd: "xxxxxx",roles: [ { role: "userAdmin", db: "website" },{ role: "dbAdmin", db: "website" },{ role: "dbOwner", db: "website" } ]})

退出后使用bbb-user登陆数据库bbb却发现登陆不上去。登陆aaa数据查看用户db.getUsers()显示

虽然创建了很多用户，但db值都是blogs,显然是不对的。即时使用use website后创建用户也是不对。正确的做法是关闭数据库认证，使用不带--auth启动数据库，使用命令行来创建

use website

db.createUser( {user: "username",pwd: "xxxxxx",roles: [ { role: "userAdmin", db: "website" },{ role: "dbAdmin", db: "website" },{ role: "dbOwner", db: "website" } ]})

这样就可以登录了。由于数据库和用户名是绑定的，只有确保用户是创建在对应数据库上才行。

linux修改MySQL 5.7.22字符集为utf8

Thu, 11 Oct 2018 10:25:53 +0000

网上也找了很多方案结果就是奇葩的不成功，最后直接修改/etc/mysql/mysql.conf.d/mysqld.cnf成功了。在该文件最后添加

default-storage-engine=INNODB
character-set-server=utf8
collation-server=utf8_general_ci

重启成功。

这是本地虚拟机里的mysql

mysql> show variables like "character%";
+--------------------------+----------------------------+
| Variable_name            | Value                      |
+--------------------------+----------------------------+
| character_set_client     | utf8                       |
| character_set_connection | utf8                       |
| character_set_database   | utf8                       |
| character_set_filesystem | binary                     |
| character_set_results    | utf8                       |
| character_set_server     | utf8                       |
| character_set_system     | utf8                       |
| character_sets_dir       | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+

完全正确，但是修改阿里云服务器以后还是有点小问题

character_set_database这一项还是latin1,不过似乎并不影响。友情提示：纠正了mysql字符集发现新建的表还是latin1字符集，那有可能是该数据库本身的字符集就不对，可以试着看看。

mongodb forEach替换文本

Sun, 30 Sep 2018 08:20:22 +0000

最近七牛云存储要收回测试域名，但是我的博客中图片使用了这些测试域名，所以要替换掉，避免图片不可访问。在文档中没有找到可以直接替换的方法，所以就使用了mongodb的forEach循环替换。首先用正则查询法查出使用了测试域名的文档，然后forEach循环，在每个循环中使用js的正则替换函数将域名替换掉，最后再保存该文档即可。

db.getCollection('blogs').find({content:{$regex:/hopefully.qiniudn.com/}}).forEach(function(item){
    item.content = item.content.replace(/hopefully.qiniudn.com/g, 'qn-img.hopefly.top')
    db.getCollection('blogs').save(item)
	print(">>", item.content);
})

mongoose查询没有响应

Thu, 06 Sep 2018 09:21:31 +0000

使用mongoose建立了连接以后，通过model查询数据，如：testModel.find(),既不报错又不返回数据。

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/my_database');

使用mongoose.connect连接产生在mongoose.connection上，使用mongoose.createConnection是反回一个连接对象，建立model的时候需要使用这个连接才有效，此时使用mongoose.model是无效的。

const conn = mongoose.createConnection('your connection string');
const MyModel = conn.model('ModelName', schema);
const m = new MyModel;
m.save(); // 可以工作

const conn = mongoose.createConnection('your connection string');
const MyModel = mongoose.model('ModelName', schema);
const m = new MyModel;
m.save(); // 不能工作

读写数据库与读写文件哪个更快？

Tue, 28 Nov 2017 15:31:19 +0000

由于开发物流信息网，关于这个问题也是最近才想到的，就是到底读文件更快还是读数据库更快，能快多少，书生也搜索过，没见有网友就这个问题答复过，也可能是太简单的缘故，我们本文还是来实测一下，由于时间关系，VC还没装，书生先用PHP测试了一下，下次有时间在C/C++上补充测试到本文来，因为 PHP的底层解析应该也是基于C的，所以估计两者环境测试结果差不多，小问题大收获，现在就来看一下测试过程及结果。

测试程序如下：

//说明1：由于读数据库语句调用简单的封包函数两次，所以把读文件也改成连续调用两次，数据库记录ID为1就在第一条，并且唯一索引。

//说明2：测试两次一次是4K数据，一次是整形数据

set_time_limit(0);
function fnGet($filename)
{
    $content = file_get_contents($filename);
    return $content;
}

function fnGetContent($filename)
{
    $content = fnGet($filename);
    return $content;
}
   
$times=100000;   
echo '数据库查询结果：<br/>';
//---------------------------------
$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
    $res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
    $row=$dbcon->mydb_fetch_row($res);
    $content=$row[0];
}
echo 'fetch_row '.$times.' 次时间：<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
//---------------------------------

$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
    $res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
    $row=$dbcon->mydb_fetch_array($res);
    $content=$row['log_Content'];   
}
echo 'fetch_array '.$times.' 次时间：<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
//---------------------------------

$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
    $res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
    $row=$dbcon->mydb_fetch_object($res);
    $content=$row->log_Content;   
}
echo 'fetch_object '.$times.' 次时间：<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
//---------------------------------

$dbcon->mydb_free_results();
$dbcon->mydb_disconnect();

fnWriteCache('test.txt',$content);

echo '直接读文件测试结果：<br/>';

//---------------------------------
$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
    $content = fnGetContent('test.txt');
}
echo 'file_get_contents直接读'.$times.'次时间：<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
//---------------------------------

$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
    $fname = 'test.txt';
    if(file_exists($fname))
     {
        $fp=fopen($fname,"r");//flock($fp,LOCK_EX);       
        $file_data=fread($fp, filesize($fname));//rewind($fp);      
        fclose($fp);
    }
    $content = fnGetContent('test.txt');
}   
echo 'fopen直接读'.$times.'次时间：<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';

结果：

4K大小数据的查询结果： fetch_row 100000 次时间：16.737720012665秒 fetch_array 100000 次时间：16.661195993423秒 fetch_object 100000 次时间：16.775065898895秒直接读文件测试结果： file_get_contents直接读100000次时间：5.4631857872009秒 fopen直接读100000次时间：11.463611125946秒

open() is deprecated in mongoose >= 4.11.0, use openUri()

Fri, 18 Aug 2017 08:18:36 +0000

`open()` is deprecated in mongoose >= 4.11.0, use `openUri()` instead, 
or set the `useMongoClient` option if using `connect()` or `createConnection()`. 
See http://mongoosejs.com/docs/connections.html#use-mongo-client
Db.prototype.authenticate method will no longer be available in the next major 
release 3.x as MongoDB 3.6 will only allow auth against users in the admin db 
and will no longer allow multiple credentials on a socket. 
Please authenticate using MongoClient.connect with auth credentials.

修改连接参数：

url = `mongodb://${this.username}:${this.password}@${this.host}:${this.port}/${this.dbName}`;

const opts = {
	// autoReconnect: false,//默认true
	// reconnectTries: 30,//尝试重连，默认30次
	// reconnectInterval: 1000, //重连间隔，默认1000毫秒
	loggerLevel: "warn", //error/warn/info/debug
	useMongoClient: true
};
mongoose.connect(this.url, opts);

如果在原有参数的基础上加了userMongoClient以后有如下警告：

mongoose自动添加createdAt和updatedAt

Sat, 10 Jun 2017 04:44:55 +0000

export var CommentSchema: Schema = new Schema({
    Id: String,
    content: String,
    status: {
        type: Boolean,
        default: true
    }
}, { timestamps: true});

添加{ timestamps: true}选项即可，如果需要自定义属性名称可以直接指定： { timestamps: {createdAt:'created_at', updatedAt:'updated_at'}}

Mongodb和mongoose模糊查询

Sat, 05 Nov 2016 05:51:40 +0000

需求说明：在mongdb中使用模糊查询，就像sql中的like查询，在where条件中使用模糊匹配，当然最重要的是需要模糊查询的字符串是动态传入的

以一篇文章为例，content字段为文章内容，我们要查询文章内容中包含Nodejs关键字的文章

mongodb中查询

select * from articles where content like '%Nodejs%';
db.articles.find( { content: /Nodejs/i } )
Article.find({ content: /Nodejs/i}, function (err, docs) {});

这种写法是一种简写操作，需要注意的是不能带双引号，带了双引号就成了字符串。但是这种写法是用/包裹了一个字符串类型的关键字，在实际程序是动态传入的，比如：

var a="Nodejs" ;
Article.find({ content: /a/i}, function (err, docs) {});

此时会把"a"当做要查询的关键字而不是"Nodejs"，所以这时还是需要用到完整的查询方式，就是使用$regex关键字，还有$options选项

var text = 'Nodejs';//动态传入的变量
Article.find({ content: { $regex: text, $options: 'i' }}, function (err, docs) {});

$options选项值：

i 大小写不敏感
m $regex包含正则^,$符号的表达式
x 忽略空格
s 允许逗点匹配所有字符串

其实$regex就是正则表达式的写法

查找数组中的字段：

contacts:{
    [
        {
            address: "address1",
            name: "张三"
        },
        {
            address: "address2",
            name: "李四"
        },
        .....
    ]
}

可以通过db.collection.find({'contacts.name':{$regex:'张'}})获得

Mongodb和mongoose聚合查询

Wed, 02 Nov 2016 09:32:39 +0000

mongdb查询某一字段sum值

需求说明：articles有一个字段pv记录了该文章的访问量，现在要统计所有文章访问量，类似于sql中的sum统计

mongodb中查询

select sum(pv) from articles;
db.articles.aggregate([{$group:{_id:null,pv:{$sum:"$pv"}}}]);
结果：{ "_id" : null, "pv" : 2 }

select sum(pv) from articles where createDate <= '2016-10-20';
db.articles.aggregate([{$match:{createDate:{$lte:"2016-10-20"}}},{$group:{_id:null,pv:{$sum:"$pv"}}}]);
结果：{ "_id" : null, "pv" : 9 }

select sum(pv) from articles where category = 'Nodejs';
db.articles.aggregate([{$match:{category:"Nodejs"}},{$group:{_id:null,pv:{$sum:"$pv"}}}]);
结果：{ "_id" : null, "pv" : 7 }

需要注意$match和$group的顺序，反了是不行的，因为这是Aggregation Pipeline（管道流）

mongoose实现方式，与上面sql的顺序对应：

Article.aggregate({ $group: { _id: null, pvCount: { $sum: '$pv' }}}, function(err, doc) {
    console.log("1", doc);
});
Article.aggregate([{$match:{createDate:{$lte:"2016-10-20"}}},{$group:{_id:null, pvCount:{$sum:"$pv"}}}], function(err, doc) {
    console.log("2", doc);
});
Article.aggregate([{$match:{category:"Nodejs"}},{$group:{_id:null, pvCount:{$sum:"$pv"}}}], function(err, doc) {
    console.log("3", doc);
});
1 [ { _id: null, pv: 25 } ]
2 [ { _id: null, pv: 9 } ]
3 [ { _id: null, pv: 7 } ]

参考文档：

系统开发中默认值的设置

Mon, 15 Feb 2016 11:29:00 +0000

多人协作开发过程中会遇到一些字段设置默认值的情况，但是这个默认值到底该由哪一阶段来设置？比如有三个阶段:前端或移动端，接口程序，数据库。说个具体场景，APP上有个医生需要显示挂号费，这个挂号费是由后台管理系统添加的，但是在添加医生这个过程不是一次性完成的，先是添加员工信息，角色为医生，这个挂号费是添加完成员工信息以后在医生管理里设置的，那么在完成添加员工后还没来得及设置挂号费医生就显示到了APP中，由于这个医生没有挂号费，就会导致用户误解或者APP程序报错。这时候问题来了，挂号费该有个默认值吧！但是这个默认值由谁来设置呢？尤其是程序上线以后出现问题大家都不想背这个黑锅，移动端问接口，你要传个默认值给我，接口对后台管理说你怎么没传个默认值给我？后台管理说，就不能在数据库设置吗，没有值我干嘛还要传？究竟该由谁来设置这个默认值，好像谁都可以，但是有很多字段要设置的时候就有很多工作量要做了，需要判断用户有没有填，没有填就设置默认值。一堆的if判断，很不明智的做法，而且也不能保证万无一失。

最后总结：默认值由数据库来设置，这是最简单的方法，可以为程序省去很多判断，而且数据库不为null的设置可以为索引字段带来好处，节省空间。

数据表索引如何建立？多列索引还是单列索引

Fri, 16 Oct 2015 09:00:52 +0000

数据库优化第一想到的应该是建立索引，而且是最快速有效的优化方式，一般是对where子句中的字段建立索引，但是并不是越多越好，对于基数(区分度)越大的效果越好，比如唯一索引。对于一些表示状态的，比如值为0,1这类区分状态的字段就算数据再多索引的基数也很小，这类字段并不是非要加索引，加的索引越多越占磁盘空间，每次写入数据都要更新大量索引，反而成为累赘。但是不要以为真的没必要加，初学者对索引的认识浅薄，要么不加索引，要么在建表时就妄自推断加了很多索引。那么如何加索引才是正确的做法呢？

数据库中有一种是单列索引，一种是多列索引，要怎么加需要搞清楚这两者的区别，当查询条件有多个字段时，单列索引和多列索引有很大的区别。
如果使用多列索引，where条件中字段的顺序非常重要，需要满足最左前缀列。

最左前缀：查询条件中的所有字段需要从左边起按顺序出现在多列索引中，查询条件的字段数要小于等于多列索引的字段数，中间字段不能存在范围查询的字段(<,like等)，这样的sql可以使用该多列索引。

mysql多列索引适合的场景

全字段匹配
匹配部分最左前缀
匹配第一列
匹配第一列范围查询(可用用like a%,但不能使用like %b)
精确匹配某一列和和范围匹配另外一列

order by操作中出现的字段同样适用于按值查找的规则，where+order by中出现的字段需可以建立满足如上五种规则多列索引。使用多列需要按照最左索引列查找；不能跳过中间列；如果某一列是范围查询，那么其右边所有列无法使用索引。 IN什么情况下是范围查询，什么情况下是多个等值查询？如果有order by排序时，多个等于条件查询就是范围查询，没有order by排序就没有限制。例如,建立多列索引(name, age, id), 只能使用索引的前两列。in是范围查询 … where name=“nginx.cn” and age in(15,16,17) order by id 可以使用整个索引，in是按值查询 … where name=“nginx.cn” and age in(15,16,17) and id =“3”

数据库优化一点总结

Thu, 08 Oct 2015 14:04:07 +0000

以前找工作的时候总被面试到数据库方面的知识，尤其是数据库优化。当然在去面试之前先补习一下，背一些网上的概念来应付。现在想想，要考察一个开发者数据库优化方面的知识只需要问一下有没有做过数据库设计和优化就行，如果做过相关工作那么多少会总结出来一些，如果没做过说出再多也是概念而已。

国庆节前韩豆咖派上线，然后这个节日就不会有好日子过了，上线三四天的时候很多用户反映帖子刷新不出来，登陆不了等问题，起初我以为是放假了大家回家网络不好导致的，后来测试了下接口花了一分多钟数据才返回，看来不是网络问题。查了下数据库帖子数量，居然达到6万了，想到以前背的概念，首先加索引试试，果然快了。但是节后数量达到12万的时候又出现了相同的问题，有点纳闷，索引页加了怎么还是慢呢？经过多次试验，分拆复杂查询后得出结论是由于查询语句中使用了left join自连接查询，通俗的说就是在12万数据中找出需要的数据，然后再在这12万中找出关联数据，光是这两个12万都够吓人了。最后还是把复杂的sql分解用程序控制查询子句，速度果然又提高了。

得出结论，一句复杂的sql不一定是最好的，分解成多句简单的sql可能有质的飞跃。这个方案在《高性能MYSQL》一书中也提到了，补充个图片：

但是对于sql查询到底该一次复杂查询还是多次简单查询没有明显界限，只有当一条复杂查询发现很慢的时候再分析慢的原因多次试验后就能知道哪个是最好的，而且复杂的sql也不利于优化，可能加了索引都没用，也不能使用查询缓存。当一条复杂的sql需要花3秒钟才能查出来的时候分拆的简单sql可能每秒可以查询5000次了.

MySQL查询当天0点，昨天

Mon, 28 Sep 2015 06:18:25 +0000

今天是

SELECT NOW();-- 2015-09-28 13:48:12

查询当天，格式为YYYY-MM-DD

SELECT CURDATE();-- 2015-09-28

查询当天，格式为YYYY-MM-DD HH:mm:ss

SELECT NOW();-- 2015-09-28 13:42:00

查询当天0点，格式为YYYY-MM-DD HH:mm:ss

SELECT DATE_FORMAT(CURDATE(),"%Y-%m-%d %H:%i:%s");-- 2015-09-28 00:00:00

查询当天早上9点，格式为YYYY-MM-DD HH:mm:ss

SELECT DATE_ADD(CURDATE(), INTERVAL 9 HOUR);-- 2015-09-28 09:00:00

查询昨天，格式为YYYY-MM-DD

SELECT DATE_SUB(CURDATE(),INTERVAL 1 DAY);-- 2015-09-27

查询昨天早上9点

SELECT DATE_ADD(DATE_SUB(CURDATE(),INTERVAL 1 DAY),INTERVAL 9 HOUR);-- 2015-09-27 09:00:00

DATE_ADD(date,INTERVAL expr type) 参数是合法的日期表达式。expr 参数是您希望增加的时间。

type 参数可以是下列值：

Type 值

MICROSECOND

SECOND

MINUTE

HOUR

DAY

WEEK

MONTH

QUARTER

YEAR

SECOND_MICROSECOND

MINUTE_MICROSECOND

MINUTE_SECOND

HOUR_MICROSECOND

HOUR_SECOND

HOUR_MINUTE

DAY_MICROSECOND

总结一下最近数据库设计原则（待补充）

Fri, 04 Sep 2015 04:27:35 +0000

在没有做过数据库设计之前认为：数据库设计是表与表的关系设计，合理的表关系设计能使逻辑更易编写，不过这是以前肤浅的认知。后来逐渐开始参与公司数据库的设计才发现，单单是数据库表名，字段名也有一定学问，在最近的开发过程中感觉尤为突出。其中一些是历史遗留发现的，另外一些是新加表中发现的。

一、遗留问题主要体现在文档缺失上，基本所有表没有注释，字段更不用说，然后就对每个字段的作用搞不清楚，而且很多字段也不知道有没有用到，因为所有记录都没有值，但又不敢删。留着不管又影响性能，看着也不爽。

二、在新加表出现的问题是：新人喜欢模仿以前的表设计，也不管字段有没有用，有什么用，先都照搬过来，而且又喜欢添加一些新字段，说是为了预留以后新加功能的时候万一用到了，这就重蹈覆辙了，把字段加上了却又不喜欢写注释，然后导致后来连自己也不知道当初为什么加这个字段。

三、另外对于一些枚举字段，用了数字来表示不同类型，比如用1，2，3，4表示超级管理员，普通管理员，用户，小编，这种方式好处是占用字节少，但是坏处也不少，首先，从数值上看不出代表什么类型，需要看文档注释，要是连注释也没写那就坑了。

四、由于业务不断增加，表字段也不管添加，最后一张表中就会有好几十个字段，最后变得不好维护，而且有些字段是做的时候加上，最后又不用了，又没有及时删掉，然后就变成了垃圾字段。

以上几点问题是比较突出又影响开发的，我也总结出了对策：
1、表和字段一定要写注释
2、只添加需要用到的字段，千万不要加一些以后用到的字段，以后用到以后加
3、枚举字段在MySQL中建议使用enum枚举类型，在插入记录的时候使用单词来表明类型，在数据库保存的实际是数值索引
4、对于常用的字段放到一个表中，不常用的字段可以考虑分表存放，一对一关联，需要的时候查询即可

数据库引擎的使用：

就目前mysql的使用来说，大多数人在数据库引擎上会选择InnoDB，也总是有人建议这么做，主要目的是为了支持事务。但同样有人认为MyISAM读取性能比InnoDB强很多，会选择使用MyISAM。所以说具体选择哪种引擎类型依据业务实际情况决定。根据我们的项目实际使用情况，我最后选择了MyISAM作为数据库引擎。

前一个项目使用java开发，MySQL数据库InnoDB，确实也出现一些问题，在某次活动时200左右的并发量下不仅服务器宕机，连另一台数据库服务器在连接数暴增的情况下读取性能骤降，从而导致java服务器不能及时响应。这次开发语言选择了nodejs，经测试发现，可以支撑的并发量在2000多近3000的样子，所以就要求数据库能尽快读取数据，再加上目前业务中不要求事务，那么MyISAM就成了不二之选。

redis启动失败

Thu, 07 May 2015 05:59:28 +0000

redis-server.exe redis.windows.conf 使用上面命令启动redis服务的时候报了以下错误信息： The Windows version of Redis allocates a memory mapped heap for sharing with the forked process used for persistence operations. In order to share this memory, Windows allocates from the system paging file a portion equal to the size of the Redis heap. At this time there is insufficient contiguous free space available in the system paging file for this operation (Windows error 0x5AF). To work around this you may either increase the size of the system paging file, or decrease the size of the Redis heap with the –maxheap flag. Sometimes a reboot will defragment the system paging file sufficiently for this operation to complete successfully.

mysql一个字段为空时使用另一个字段排序

Mon, 20 Apr 2015 10:17:38 +0000

表中有两个日期字段createDate，updateDate。其中updateDate可以为空，要求使用updateDate排序，如果updateDate为空则使用createDate排序，结果要顺序排下来。

按照常规方法：

select * from table order by updateDate desc;

这样的结果是为空的数据排在了最下面，不符合要求。

这样试试：

select * from table order by updateDate desc, createDate desc;

这样排的结果是先按updateDate排序，updateDate为空的排在最下面，然后按createDate排序，这样也不符合要求。

正确方法：

select * from table order by IFNULL(updateDate, createDate) desc;

这种排序的结果是正确的，用ifnull函数判断updateDate如果为空的话就使用createDate排。

mongodb启动服务失败的解决办法之一

Sun, 16 Nov 2014 03:46:38 +0000

在执行下面第一行启动mongodb服务的时候，命令行一闪而过，具体看了下输出内容看不出端倪来，不过解决办法却是有的，就是直接删除掉D:\Data\db下面的mongod.lock文件可以了

C:\Program Files\MongoDB 2.6 Standard\bin>mongod –dbpath=D:\Data\db
2014-11-16T11:35:43.244+0800
2014-11-16T11:35:43.252+0800 warning: 32-bit servers don"t have journaling enabl
ed by default. Please use –journal if you want durability.
2014-11-16T11:35:43.253+0800
2014-11-16T11:35:43.282+0800 [initandlisten] MongoDB starting : pid=8272 port=27
017 dbpath=D:\Data\db 32-bit host=hp
2014-11-16T11:35:43.283+0800 [initandlisten]
2014-11-16T11:35:43.284+0800 [initandlisten] ** NOTE: This is a 32 bit MongoDB b
inary.
2014-11-16T11:35:43.284+0800 [initandlisten] ** 32 bit builds are limited
to less than 2GB of data (or less with –journal).
2014-11-16T11:35:43.284+0800 [initandlisten] ** Note that journaling defau
lts to off for 32 bit and is currently off.
2014-11-16T11:35:43.285+0800 [initandlisten] ** See http://dochub.mongodb.
org/core/32bit
2014-11-16T11:35:43.286+0800 [initandlisten]
2014-11-16T11:35:43.286+0800 [initandlisten] targetMinOS: Windows XP SP3
2014-11-16T11:35:43.286+0800 [initandlisten] db version v2.6.4
2014-11-16T11:35:43.287+0800 [initandlisten] git version: 3a830be0eb92d772aa855e
bb711ac91d658ee910
2014-11-16T11:35:43.287+0800 [initandlisten] build info: windows sys.getwindowsv
ersion(major=6, minor=1, build=7601, platform=2, service_pack=“Service Pack 1”)
BOOST_LIB_VERSION=1_49
2014-11-16T11:35:43.290+0800 [initandlisten] allocator: system
2014-11-16T11:35:43.292+0800 [initandlisten] options: { storage: { dbPath: “D:\D
ata\db” } }
**************
Unclean shutdown detected.
Please visit http://dochub.mongodb.org/core/repair for recovery instructions.
*************
2014-11-16T11:35:43.360+0800 [initandlisten] exception in initAndListen: 12596 o
ld lock file, terminating
2014-11-16T11:35:43.362+0800 [initandlisten] dbexit:
2014-11-16T11:35:43.364+0800 [initandlisten] shutdown: going to close listening
sockets…
2014-11-16T11:35:43.365+0800 [initandlisten] shutdown: going to flush diaglog…

oracle decode和nvl的用法

Wed, 05 Nov 2014 08:16:19 +0000

Oracle 中 decode 函数用法

含义解释： decode(条件,值1,返回值1,值2,返回值2,…值n,返回值n,缺省值)

该函数的含义如下：

IF 条件=值1 THEN
　　　　RETURN(翻译值1)
ELSIF 条件=值2 THEN
　　　　RETURN(翻译值2)
　　　　......
ELSIF 条件=值n THEN
　　　　RETURN(翻译值n)
ELSE
　　　　RETURN(缺省值)
END IF

decode(字段或字段的运算，值1，值2，值3）

这个函数运行的结果是，当字段或字段的运算的值等于值1时，该函数返回值2，否则返回值3 当然值1，值2，值3也可以是表达式，这个函数使得某些sql语句简单了许多

使用方法： 1、比较大小 select decode(sign(变量1-变量2),-1,变量1,变量2) from dual; --取较小值 sign()函数根据某个值是0、正数还是负数，分别返回0、1、-1 例如：变量1=10，变量2=20 则sign(变量1-变量2)返回-1，decode解码结果为“变量1”，达到了取较小值的目的。

2、此函数用在SQL语句中，功能介绍如下：

Decode函数与一系列嵌套的 IF-THEN-ELSE语句相似。base_exp与compare1,compare2等等依次进行比较。如果base_exp和第i 个compare项匹配，就返回第i 个对应的value 。如果base_exp与任何的compare值都不匹配，则返回default。每个compare值顺次求值，如果发现一个匹配，则剩下的compare值（如果还有的话）就都不再求值。一个为NULL的base_exp被认为和NULL compare值等价。如果需要的话，每一个compare值都被转换成和第一个compare 值相同的数据类型，这个数据类型也是返回值的类型。

Decode函数在实际开发中非常的有用

结合Lpad函数，如何使主键的值自动加1并在前面补0 select LPAD(decode(count(记录编号),0,1,max(to_number(记录编号)+1)),14,'0') 记录编号 from tetdmis

eg:

select decode(dir,1,0,1) from a1_interval

dir 的值是1变为0，是0则变为1

比如我要查询某班男生和女生的数量分别是多少?

通常我们这么写:

select count(*) from 表 where 性别 ＝ 男；

select count(*) from 表 where 性别 ＝ 女；

要想显示到一起还要union一下，太麻烦了

mongoose实现翻页

Fri, 17 Oct 2014 05:01:08 +0000

随着吐槽的内容越来越多，单页显示就显得不够文雅了，分页功能是一个完整系统必备的。所以就决定加上这个功能，不过分页实现起来并不容易，找了下前辈们的资料，感觉都很复杂，所以还是实现一个简单翻页好了，就是只有上一页，下一页这样简单的功能。

首先看下mongoose API，find方法源码：

Model.find = function find (conditions, fields, options, callback){
if("function"==typeof conditions){
    callback = conditions;
    conditions ={};
    fields = null;
    options = null;
}elseif("function"==typeof fields){
    callback = fields;
    fields = null;
     options = null;
 }elseif("function"==typeof options){
     callback = options;
     options = null;
 }
 // get the raw mongodb collection object
   var mq =newQuery({}, options,this,this.collection);
   mq.select(fields);
 if(this.schema.discriminatorMapping &amp;&amp; mq._selectedInclusively()){
     mq.select(this.schema.options.discriminatorKey);
 }
 return mq.find(conditions, callback);
 };

其中有4个参数，find(条件，需要查询的字段，选项，回调)，这样看着太抽象，来一段实际应用的代码：

router.get("/admin/blogList", function(req, res) {  
    var user = req.session.user;  
    var pageIndex = 1;  
    var pageSize = 5;  
    pageIndex = req.query.pageIndex == undefined ? pageIndex  
            : req.query.pageIndex;  
    pageSize = req.query.pageSize == undefined ? pageSize : req.query.pageSize;  
    Blog.find({}, null, {  
        sort : {  
            "_id" : -1  
        },  
        skip : (pageIndex - 1) \* pageSize,  
        limit : pageSize  
    }, function(err, docs) {  
        if (err)  
            res.send(err.message);  
        res.render("admin/bloglist", {  
            blogList : docs,  
            user : user,  
            pageIndex : pageIndex,  
            pageCount : docs.length  
        });  
    });  
});

其中Blog.find({},null,{sort:{"_id":-1}, skip :( pageIndex -1)* pageSize, limit : pageSize },function)
这一段第一个参数为空，意思查询所有，第二个参数null,查询所有字段，第三个参数有倒序，分页。
然后就是页面上两个翻页按钮：