mysql Incorrect datetime value

从本地 迁移数据库到测试服 发现sql报错 MySQL []> INSERT INTO `table` VALUES (1, 1, 1, 1, 0, 0, 0, 0, 0, '0000-00-00 00:00:00', '0000-00-00 00:00:00', '0000-00-00 00:00:00', '0000-00-00 00:00:00', '2017-08-31 11:41:22', '2017-08-31 11:41:26', 0); ERROR 1292 (22007): Incorrect datetime value: '0000-00-00 00:00:00' for column 'rental_days_at' at row 1 MySQL [nparis]> select @@sql_mode; +-------------------------------------------------------------------------------------------------------------------------------------------+ | @@sql_mode | +-------------------------------------------------------------------------------------------------------------------------------------------+ | ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION | +-------------------------------------------------------------------------------------------------------------------------------------------+ 1 row in set (0.41 sec) MySQL []> set @@sql_mode='no_engine_substitution'; Query OK, 0 rows affected, 1 warning (0.07 sec) MySQL []> INSERT INTO `table` VALUES (1, 1, 1, 1, 0, 0, 0, 0, 0, '0000-00-00 00:00:00', '0000-00-00 00:00:00', '0000-00-00 00:00:00', '0000-00-00 00:00:00', '2017-08-31 11:41:22', '2017-08-31 11:41:26', 0); Query OK, 1 row affected (0.56 sec) 出自 https://dba.stackexchange.com/questions/48704/mysql-5-6-datetime-incorrect-datetime-value-2013-08-25t1700000000-with-er

ubuntu 16.10 重置mysql5.7密码

sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf [mysqld]下加入"skip-grant-tables" sudo /etc/init.d/mysql restart mysql -u root update mysql.user set authentication_string=password('123456') where user='root';(mysql5.7取消了password字段) update user set plugin="mysql_native_password"; flush privileges; exit; 注释 [mysqld]下加入"skip-grant-tables" sudo /etc/init.d/mysql restart mysql -u root -p123456

redis 发布与订阅(pub/sub)

SUBSCRIBE 、 UNSUBSCRIBE 和 PUBLISH 三个命令实现了发布与订阅信息泛型(Publish/Subscribe messaging paradigm), 在这个实现中, 发送者(发送信息的客户端)不是将信息直接发送给特定的接收者(接收信息的客户端), 而是将信息发送给频道(channel), 然后由频道将信息转发给所有对这个频道感兴趣的订阅者。 发送者无须知道任何关于订阅者的信息, 而订阅者也无须知道是那个客户端给它发送信息, 它只要关注自己感兴趣的频道即可。 对发布者和订阅者进行解构(decoupling), 可以极大地提高系统的扩展性(scalability), 并得到一个更动态的网络拓扑(network topology)。 比如说, 要订阅频道 foo 和 bar , 客户端可以使用频道名字作为参数来调用 SUBSCRIBE 命令:
redis> SUBSCRIBE foo bar
当有客户端发送信息到这些频道时, Redis 会将传入的信息推送到所有订阅这些频道的客户端里面。 正在订阅频道的客户端不应该发送除 SUBSCRIBE 和 UNSUBSCRIBE 之外的其他命令。 其中, SUBSCRIBE 可以用于订阅更多频道, 而UNSUBSCRIBE 则可以用于退订已订阅的一个或多个频道。 SUBSCRIBE 和 UNSUBSCRIBE 的执行结果会以信息的形式返回, 客户端可以通过分析所接收信息的第一个元素, 从而判断所收到的内容是一条真正的信息, 还是 SUBSCRIBE 或 UNSUBSCRIBE 命令的操作结果。

信息的格式

频道转发的每条信息都是一条带有三个元素的多条批量回复(multi-bulk reply)。 信息的第一个元素标识了信息的类型:
  • subscribe : 表示当前客户端成功地订阅了信息第二个元素所指示的频道。 而信息的第三个元素则记录了目前客户端已订阅频道的总数。
  • unsubscribe : 表示当前客户端成功地退订了信息第二个元素所指示的频道。 信息的第三个元素记录了客户端目前仍在订阅的频道数量。 当客户端订阅的频道数量降为 0 时, 客户端不再订阅任何频道, 它可以像往常一样, 执行任何 Redis 命令。
  • message : 表示这条信息是由某个客户端执行 PUBLISH 命令所发送的, 真正的信息。 信息的第二个元素是信息来源的频道, 而第三个元素则是信息的内容。
举个例子, 如果客户端执行以下命令:
redis> SUBSCRIBE first second
那么它将收到以下回复:
1) "subscribe"
2) "first"
3) (integer) 1

1) "subscribe"
2) "second"
3) (integer) 2
如果在这时, 另一个客户端执行以下 PUBLISH 命令:
redis> PUBLISH second Hello
那么之前订阅了 second 频道的客户端将收到以下信息:
1) "message"
2) "second"
3) "hello"
当订阅者决定退订所有频道时, 它可以执行一个无参数的 UNSUBSCRIBE 命令:
redis> UNSUBSCRIBE
这个命令将接到以下回复:
1) "unsubscribe"
2) "second"
3) (integer) 1

1) "unsubscribe"
2) "first"
3) (integer) 0

订阅模式

Redis 的发布与订阅实现支持模式匹配(pattern matching): 客户端可以订阅一个带 * 号的模式, 如果某个/某些频道的名字和这个模式匹配, 那么当有信息发送给这个/这些频道的时候, 客户端也会收到这个/这些频道的信息。 比如说,执行命令
redis> PSUBSCRIBE news.*
的客户端将收到来自 news.art.figurative 、 news.music.jazz 等频道的信息。 客户端订阅的模式里面可以包含多个 glob 风格的通配符, 比如 * 、 ? 和 [...] , 等等。 执行命令
redis> PUNSUBSCRIBE news.*
将退订 news.* 模式, 其他已订阅的模式不会被影响。 通过订阅模式接收到的信息, 和通过订阅频道接收到的信息, 这两者的格式不太一样:
  • 通过订阅模式而接收到的信息的类型为 pmessage : 这代表有某个客户端通过 PUBLISH 向某个频道发送了信息, 而这个频道刚好匹配了当前客户端所订阅的某个模式。 信息的第二个元素记录了被匹配的模式, 第三个元素记录了被匹配的频道的名字, 最后一个元素则记录了信息的实际内容。
客户端处理 PSUBSCRIBE 和 PUNSUBSCRIBE 返回值的方式, 和客户端处理 SUBSCRIBE 和 UNSUBSCRIBE 的方式类似: 通过对信息的第一个元素进行分析, 客户端可以判断接收到的信息是一个真正的信息, 还是 PSUBSCRIBE 或 PUNSUBSCRIBE 命令的返回值。

通过频道和模式接收同一条信息

如果客户端订阅的多个模式匹配了同一个频道, 或者客户端同时订阅了某个频道、以及匹配这个频道的某个模式, 那么它可能会多次接收到同一条信息。 举个例子, 如果客户端执行了以下命令:
SUBSCRIBE foo
PSUBSCRIBE f*
那么当有信息发送到频道 foo 时, 客户端将收到两条信息: 一条来自频道 foo ,信息类型为 message ; 另一条来自模式 f* ,信息类型为 pmessage 。

订阅总数

在执行 SUBSCRIBE 、 UNSUBSCRIBE 、 PSUBSCRIBE 和 PUNSUBSCRIBE 命令时, 返回结果的最后一个元素是客户端目前仍在订阅的频道和模式总数。 当客户端退订所有频道和模式, 也即是这个总数值下降为 0 的时候, 客户端将退出订阅与发布状态。

编程示例

Pieter Noordhuis 提供了一个使用 EventMachine 和 Redis 编写的 高性能多用户网页聊天软件 , 这个软件很好地展示了发布与订阅功能的用法。

客户端库实现提示

因为所有接收到的信息都会包含一个信息来源:
  • 当信息来自频道时,来源是某个频道;
  • 当信息来自模式时,来源是某个模式。
因此, 客户端可以用一个哈希表, 将特定来源和处理该来源的回调函数关联起来。 当有新信息到达时, 程序就可以根据信息的来源, 在 O(1) 复杂度内, 将信息交给正确的回调函数来处理。 原文地址 http://redis.readthedocs.org/en/latest/topic/pubsub.html

redis 排序

本篇文章介绍下redis排序命令.redis支持对list,set和sorted set元素的排序。排序命令是sort 完整的命令格式如下: SORT key [BY pattern] [LIMIT start count] [GET pattern] [ASC|DESC] [ALPHA] [STORE dstkey] 下面我们一一说明各种命令选项 (1)sort key 这个是最简单的情况,没有任何选项就是简单的对集合自身元素排序并返回排序结果.下面给个例子
redis> lpush ml 12
(integer) 1
redis> lpush ml 11
(integer) 2
redis> lpush ml 23
(integer) 3
redis> lpush ml 13
(integer) 4
redis> sort ml
1. "11"
2. "12"
3. "13"
4. "23"
(2)[ASC|DESC] [ALPHA] sort默认的排序方式(asc)是从小到大排的,当然也可以按照逆序或者按字符顺序排。逆序可以加上desc选项,想按字母顺序排可以加alpha选项,当然alpha可以和desc一起用。下面是个按字母顺序排的例子
redis> lpush mylist baidu
(integer) 1
redis> lpush mylist hello
(integer) 2
redis> lpush mylist xhan
(integer) 3
redis> lpush mylist soso
(integer) 4
redis> sort mylist
1. "soso"
2. "xhan"
3. "hello"
4. "baidu"
redis> sort mylist alpha
1. "baidu"
2. "hello"
3. "soso"
4. "xhan"
redis> sort mylist desc alpha
1. "xhan"
2. "soso"
3. "hello"
4. "baidu"
(3)[BY pattern] 除了可以按集合元素自身值排序外,还可以将集合元素内容按照给定pattern组合成新的key,并按照新key中对应的内容进行排序。下面的例子接着使用第一个例子中的ml集合做演示:
redis> set name11 nihao
OK
redis> set name12 wo
OK
redis> set name13 shi
OK
redis> set name23 lala
OK
redis> sort ml by name* 
1. "13"
2. "23"
3. "11"
4. "12"
*代表了ml中的元素值,所以这个排序是按照name12 name13 name23 name23这四个key对应值排序的,当然返回的还是排序后ml集合中的元素 (对排序结果有疑问可看最下面的FAQ)
(4)[GET pattern]  上面的例子都是返回的ml集合中的元素。我们也可以通过get选项去获取指定pattern作为新key对应的值。看个组合起来的例子
redis> sort ml by name* get name*  alpha
1. "lala"
2. "nihao"
3. "shi"
4. "wo"
这 次返回的就不在是ml中的元素了,而是name12 name13 name23 name23对应的值。当然排序是按照name12 name13 name23 name23值并根据字母顺序排的。另外get选项可以有多个。看例子(#特殊符号引用的是原始集合也就是ml)
redis> sort ml by name* get name* get #  alpha
1. "lala"
2. "23"
3. "nihao"
4. "11"
5. "shi"
6. "13"
7. "wo"
8. "12"
最后在还有一个引用hash类型字段的特殊字符->,下面是例子
redis> hset user1 name hanjie
(integer) 1
redis> hset user11 name hanjie
(integer) 1
redis> hset user12 name 86
(integer) 1
redis> hset user13 name lxl
(integer) 1
redis> sort ml get user*->name
1. "hanjie"
2. "86"
3. "lxl"
4. (nil)
很容易理解,注意当对应的user23不存在时候返回的是nil (5) [LIMIT start count]  上面例子返回结果都是全部。limit选项可以限定返回结果的数量。例子
redis> sort ml get name* limit 1 2
1. "wo"
2. "shi"
start下标是从0开始的,这里的limit选项意思是从第二个元素开始获取2个 (6)[STORE dstkey] 如果对集合经常按照固定的模式去排序,那么把排序结果缓存起来会减少不少cpu开销.使用store选项可以将排序内容保存到指定key中。保存的类型是list
redis> sort ml get name* limit 1 2 store cl
(integer) 2
redis> type cl
list
redis> lrange cl 0 -1
1. "wo"
2. "shi"
这个例子我们将排序结果保存到了cl中
      功能介绍完后,再讨论下关于排序的一些问题。如果我们有多个redis server的话,不同的key可能存在于不同的server上。比如name12 name13 name23 name23,很有可能分别在四个不同的server上存贮着。这种情况会对排序性能造成很大的影响。redis作者在他的blog上提到了这个问题的解 决办法,就是通过key tag将需要排序的key都放到同一个server上 。由于具体决定哪个key存在哪个服务器上一般都是在client端hash的办法来做的。我们可以通过只对key的部分进行hash.举个例子假如我们 的client如果发现key中包含[]。那么只对key中[]包含的内容进行hash。我们将四个name相关的key,都这样命名[name]12 [name]13 [name]23 [name]23,于是client 程序就会把他们都放到同一server上。不知道jredis实现了没。 还有一个问题也比较严重。如果要sort的集合非常大的话排序就会消耗很长时间。由于redis单线程的,所以长时间的排序操作会阻塞其他client的 请求。解决办法是通过主从复制机制将数据复制到多个slave上。然后我们只在slave上做排序操作。并进可能的对排序结果缓存。另外就是一个方案是就 是采用sorted set对需要按某个顺序访问的集合建立索引。
实例:
redis> sadd tom:friend:list  123 #tom的好友列表 里面是好友的uid 
1 
redis> sadd tom:friend:list  456 
1 
redis> sadd tom:friend:list  789 
1 
redis> sadd tom:friend:list  101 
1 
redis> set uid:sort:123 1000 #uid对应的成绩 
OK 
redis> set uid:sort:456 6000 
OK 
redis> set uid:sort:789 100 
OK 
redis> set uid:sort:101 5999 
OK 
redis> set uid:123 "{'uid':123,'name':'lucy'}" #增加uid对应好友信息 
OK 
redis> set uid:456 "{'uid':456,'name':'jack'}" 
OK 
redis> set uid:789 "{'uid':789,'name':'marry'}" 
OK 
redis> set uid:101 "{'uid':101,'name':'icej'}"  
OK 
redis> sort tom:friend:list by uid:sort:* get uid:* #从好友列表中获得id与uid:sort字段匹配后排序,并根据排序后的顺序,用key在uid表获得信息 
1. {'uid':789,'name':'marry'} 
2. {'uid':123,'name':'lucy'} 
3. {'uid':101,'name':'icej'} 
4. {'uid':456,'name':'jack'} 
redis> sort tom:friend:list by uid:sort:* get uid:* get uid:sort:* 
1. {'uid':789,'name':'marry'} 
2. 100 
3. {'uid':123,'name':'lucy'} 
4. 1000 
5. {'uid':101,'name':'icej'} 
6. 5999 
7. {'uid':456,'name':'jack'} 
8. 6000
FAQ:
1.sort ml by name* get name* get # 为什么会按照shi lala nihao wo的顺序排下来,这个跟单纯的排序name*和name * alpha的结果都不一样
    这个问题要从redis的实现逻辑上来分析了
    a)list在插入后 ,默认是按照时间的先后反序排列的 , lrange ml 0 -1,结果是:13 23 11 12. 这是因为list插入时是将最新的item插入到链表头
    b)sort m1 by name* 确定是会按照name*的值进行排序的.但当name*对应的value不是num型并且没有设置alpha的时候,会导致排序分值都是相同的,因为程序将把name*对应的值尝试转换为nun型
    c)这就会导致sort ml by name*会按照ml的自然顺序进行排列了
if (alpha) {
if (sortby) vector[j].u.cmpobj = getDecodedObject(byval);
} else {
if (byval->encoding == REDIS_ENCODING_RAW) {
    vector[j].u.score = strtod(byval->ptr,NULL);
} else if (byval->encoding == REDIS_ENCODING_INT) {
    /* Don't need to decode the object if it's
     * integer-encoded (the only encoding supported) so
     * far. We can just cast it */
    vector[j].u.score = (long)byval->ptr;
} else {
    redisAssert(1 != 1); 
}   
}

redis 数据类型

本文介绍下redis支持的各种数据类型包括string,list ,set ,sorted set 和hash 1. keys redis本质上一个key-value db,所以我们首先来看看他的key.首先key也是字符串类型,但是key中不能包括边界字符 由于key不是binary safe的字符串,所以像"my key"和"mykey\n"这样包含空格和换行的key是不允许的 顺便说一下在redis内部并不限制使用binary字符,这是redis协议限制的。"\r\n"在协议格式中会作为特殊字符。 redis 1.2以后的协议中部分命令已经开始使用新的协议格式了(比如MSET)。总之目前还是把包含边界字符当成非法的key吧, 免得被bug纠缠。 另外关于key的一个格式约定介绍下,object-type:id:field。比如user:1000:password,blog:xxidxx:title 还有key的长度最好不要太长。道理很明显占内存啊,而且查找时候相对短key也更慢。不过也推荐过短的key, 比如u:1000:pwd,这样的。显然没上面的user:1000:password可读性好。 下面介绍下key相关的命令 exits key 测试指定key是否存在,返回1表示存在,0不存在 del key1 key2 ....keyN  删除给定key,返回删除key的数目,0表示给定key都不存在 type key 返回给定key的value类型。返回 none 表示不存在key,string字符类型,list 链表类型 set 无序集合类型... keys pattern 返回匹配指定模式的所有key,下面给个例子 randomkey 返回从当前数据库中随机选择的一个key,如果当前数据库是空的,返回空串 rename oldkey newkey 原子的重命名一个key,如果newkey存在,将会被覆盖,返回1表示成功,0失败。可能是oldkey不存在或者和newkey相同 renamenx oldkey newkey 同上,但是如果newkey存在返回失败 dbsize 返回当前数据库的key数量 expire key seconds 为key指定过期时间,单位是秒。返回1成功,0表示key已经设置过过期时间或者不存在 ttl key 返回设置过过期时间的key的剩余过期秒数 -1表示key不存在或者没有设置过过期时间 select db-index 通过索引选择数据库,默认连接的数据库所有是0,默认数据库数是16个。返回1表示成功,0失败 move key db-index  将key从当前数据库移动到指定数据库。返回1成功。0 如果key不存在,或者已经在指定数据库中 flushdb 删除当前数据库中所有key,此方法不会失败。慎用 flushall 删除所有数据库中的所有key,此方法不会失败。更加慎用 2. string 类型 string是redis最基本的类型,而且string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。从内部实现来看其实string可以看作byte数组,最大上限是1G字节。下面是string类型的定义。
struct sdshdr {
    long len;
    long free;
    char buf[];
};
buf是个char数组用于存贮实际的字符串内容。其实char和c#中的byte是等价的,都是一个字节 len是buf数组的长度,free是数组中剩余可用字节数。由此可以理解为什么string类型是二进制安全的了。因为它本质上就是个byte数组。 当然可以包含任何数据了。另外string类型可以被部分命令按int处理.比如incr等命令,下面详细介绍。还有redis的其他类型像list,set,sorted set ,hash 它们包含的元素与都只能是string类型。 如果只用string类型,redis就可以被看作加上持久化特性的memcached.当然redis对string类型的操作比memcached多很多啊。如下: set key value 设置key对应的值为string类型的value,返回1表示成功,0失败 setnx key value 同上,如果key已经存在,返回0 。nx 是not exist的意思 get key 获取key对应的string值,如果key不存在返回nil getset key value 原子的设置key的值,并返回key的旧值。如果key不存在返回nil mget key1 key2 ... keyN 一次获取多个key的值,如果对应key不存在,则对应返回nil。下面是个实验,首先清空当前数据库,然后 设置k1,k2.获取时k3对应返回nil
redis> flushdb
OK
redis> dbsize
(integer) 0
redis> set k1 a
OK
redis> set k2 b
OK
redis> mget k1 k2 k3
1. "a"
2. "b"
3. (nil)
mset key1 value1 ... keyN valueN 一次设置多个key的值,成功返回1表示所有的值都设置了,失败返回0表示没有任何值被设置 msetnx key1 value1 ... keyN valueN 同上,但是不会覆盖已经存在的key incr key 对key的值做加加操作,并返回新的值。注意incr一个不是int的value会返回错误,incr一个不存在的key,则设置key为1 decr key 同上,但是做的是减减操作,decr一个不存在key,则设置key为-1 incrby key integer 同incr,加指定值 ,key不存在时候会设置key,并认为原来的value是 0 decrby key integer 同decr,减指定值。decrby完全是为了可读性,我们完全可以通过incrby一个负值来实现同样效果,反之一样。
substr 返回截取过的key的字符串值,注意并不修改key的值。下标是从0开始的.(redis在2.0版本以后不包括2.0,使用的方法是getrange 参数相同。) append key value  给指定key的字符串值追加value,返回新字符串值的长度。下面给个例子
redis> set k hello
OK
redis> append k ,world
(integer) 11
redis> get k
"hello,world"
substr key start end
redis> substr k 0 8
"hello,wor"
redis> get k
"hello,world"
3. list redis的list类型其实就是一个每个子元素都是string类型的双向链表。所以[lr]push和[lr]pop命令的算法时间复杂度都是O(1) 另外list会记录链表的长度。所以llen操作也是O(1).链表的最大长度是(2的32次方-1)。我们可以通过push,pop操作从链表的头部 或者尾部添加删除元素。这使得list既可以用作栈,也可以用作队列。有意思的是list的pop操作还有阻塞版本的。当我们[lr]pop一个 list对象是,如果list是空,或者不存在,会立即返回nil。但是阻塞版本的b[lr]pop可以则可以阻塞,当然可以加超时时间,超时后也会返回nil 。为什么要阻塞版本的pop呢,主要是为了避免轮询。举个简单的例子如果我们用list来实现一个工作队列。执行任务的thread可以调用阻塞版本的pop去 获取任务这样就可以避免轮询去检查是否有任务存在。当任务来时候工作线程可以立即返回,也可以避免轮询带来的延迟。ok下面介绍list相关命令 lpush key string 在key对应list的头部添加字符串元素,返回1表示成功,0表示key存在且不是list类型 rpush key string 同上,在尾部添加 llen key 返回key对应list的长度,key不存在返回0,如果key对应类型不是list返回错误 lrange key start end 返回指定区间内的元素,下标从0开始,负值表示从后面计算,-1表示倒数第一个元素 ,key不存在返回空列表 ltrim key start end  截取list,保留指定区间内元素,成功返回1,key不存在返回错误 lset key index value 设置list中指定下标的元素值,成功返回1,key或者下标不存在返回错误 lrem key count value 从key对应list中删除count个和value相同的元素。count为0时候删除全部 lpop key 从list的头部删除元素,并返回删除元素。如果key对应list不存在或者是空返回nil,如果key对应值不是list返回错误 rpop 同上,但是从尾部删除 blpop key1...keyN timeout 从左到右扫描返回对第一个非空list进行lpop操作并返回,比如blpop list1 list2 list3 0 ,如果list不存在 list2,list3都是非空则对list2做lpop并返回从list2中删除的元素。如果所有的list都是空或不存在,则会阻塞timeout秒,timeout为0表示一直阻塞。 当阻塞时,如果有client对key1...keyN中的任意key进行push操作,则第一在这个key上被阻塞的client会立即返回。如果超时发生,则返回nil。有点像unix的select或者poll brpop 同blpop,一个是从头部删除一个是从尾部删除 rpoplpush srckey destkey 从srckey对应list的尾部移除元素并添加到destkey对应list的头部,最后返回被移除的元素值,整个操作是原子的.如果srckey是空 或者不存在返回nil 4. set redis的set是string类型的无序集合。set元素最大可以包含(2的32次方-1)个元素。set的是通过hash table实现的,所以添加,删除,查找的复杂度都是O(1)。hash table会随着添加或者删除自动的调整大小。需要注意的是调整hash table大小时候需要同步(获取写锁)会阻塞其他读写操作。可能不久后就会改用跳表(skip list)来实现 跳表已经在sorted set中使用了。关于set集合类型除了基本的添加删除操作,其他有用的操作还包含集合的取并集(union),交集(intersection), 差集(difference)。通过这些操作可以很容易的实现sns中的好友推荐和blog的tag功能。下面详细介绍set相关命令 sadd key member 添加一个string元素到,key对应的set集合中,成功返回1,如果元素以及在集合中返回0,key对应的set不存在返回错误 srem key member 从key对应set中移除给定元素,成功返回1,如果member在集合中不存在或者key不存在返回0,如果key对应的不是set类型的值返回错误 spop key 删除并返回key对应set中随机的一个元素,如果set是空或者key不存在返回nil srandmember key 同spop,随机取set中的一个元素,但是不删除元素 smove srckey dstkey member 从srckey对应set中移除member并添加到dstkey对应set中,整个操作是原子的。成功返回1,如果member在srckey中不存在返回0,如果 key不是set类型返回错误 scard key 返回set的元素个数,如果set是空或者key不存在返回0 sismember key member 判断member是否在set中,存在返回1,0表示不存在或者key不存在 sinter key1 key2...keyN 返回所有给定key的交集 sinterstore dstkey key1...keyN 同sinter,但是会同时将交集存到dstkey下 sunion key1 key2...keyN 返回所有给定key的并集 sunionstore dstkey key1...keyN 同sunion,并同时保存并集到dstkey下 sdiff key1 key2...keyN 返回所有给定key的差集 sdiffstore dstkey key1...keyN 同sdiff,并同时保存差集到dstkey下 smembers key 返回key对应set的所有元素,结果是无序的 5 sorted set 和set一样sorted set也是string类型元素的集合,不同的是每个元素都会关联一个double类型的score。sorted set的实现是skip list和hash table的混合体 当元素被添加到集合中时,一个元素到score的映射被添加到hash table中,所以给定一个元素获取score的开销是O(1),另一个score到元素的映射被添加到skip list 并按照score排序,所以就可以有序的获取集合中的元素。添加,删除操作开销都是O(log(N))和skip list的开销一致,redis的skip list实现用的是双向链表,这样就 可以逆序从尾部取元素。sorted set最经常的使用方式应该是作为索引来使用.我们可以把要排序的字段作为score存储,对象的id当元素存储。下面是sorted set相关命令 zadd key score member 添加元素到集合,元素在集合中存在则更新对应score zrem key member 删除指定元素,1表示成功,如果元素不存在返回0 zincrby key incr member 增加对应member的score值,然后移动元素并保持skip list保持有序。返回更新后的score值 zrank key member 返回指定元素在集合中的排名(下标),集合中元素是按score从小到大排序的 zrevrank key member 同上,但是集合中元素是按score从大到小排序 zrange key start end 类似lrange操作从集合中去指定区间的元素。返回的是有序结果 zrevrange key start end 同上,返回结果是按score逆序的 zrangebyscore key min max 返回集合中score在给定区间的元素 zcount key min max 返回集合中score在给定区间的数量 zcard key 返回集合中元素个数 zscore key element  返回给定元素对应的score zremrangebyrank key min max 删除集合中排名在给定区间的元素 zremrangebyscore key min max 删除集合中score在给定区间的元素 6. hash  redis hash是一个string类型的field和value的映射表.它的添加,删除操作都是O(1)(平均).hash特别适合用于存储对象。相较于将对象的每个字段存成 单个string类型。将一个对象存储在hash类型中会占用更少的内存,并且可以更方便的存取整个对象。省内存的原因是新建一个hash对象时开始是用zipmap(又称为small hash)来存储的。这个zipmap其实并不是hash table,但是zipmap相比正常的hash实现可以节省不少hash本身需要的一些元数据存储开销。尽管zipmap的添加,删除,查找都是O(n),但是由于一般对象的field数量都不太多。所以使用zipmap也是很快的,也就是说添加删除平均还是O(1)。如果field或者value的大小超出一定限制后,redis会在内部自动将zipmap替换成正常的hash实现. 这个限制可以在配置文件中指定
redis> set test dsf
OK
redis> set tast dsaf
OK
redis> set tist adff
OK
redis> keys t*
1. "tist"
2. "tast"
3. "test"
redis> keys t[ia]st
1. "tist"
2. "tast"
redis> keys t?st
1. "tist"
2. "tast"
3. "test"
hash-max-zipmap-entries 64 #配置字段最多64个 hash-max-zipmap-value 512 #配置value最大为512字节 下面介绍hash相关命令 hset key field value 设置hash field为指定值,如果key不存在,则先创建 hget key field  获取指定的hash field hmget key filed1....fieldN 获取全部指定的hash filed hmset key filed1 value1 ... filedN valueN 同时设置hash的多个field hincrby key field integer 将指定的hash filed 加上给定值 hexists key field 测试指定field是否存在 hdel key field 删除指定的hash field hlen key 返回指定hash的field数量 hkeys key 返回hash的所有field hvals key 返回hash的所有value hgetall 返回hash的所有filed和value 原文地址http://www.cnblogs.com/xhan/archive/2011/02/02/1948891.html

PHP操作MongoDB

(“mongodb://用户名:密码 @地址:端口/默认指定数据库”,参数) $conn = new Mongo(); //可以简写为 //$conn=new Mongo(); #连接本地主机,默认端口. //$conn=new Mongo(“172.21.15.69″); #连接远程主机 //$conn=new Mongo(“xiaocai.loc:10086″); #连接指定端口远程主机 //$conn=new Mongo(“xiaocai.loc”,array(“replicaSet”=>true)); #负载均衡 //$conn=new Mongo(“xiaocai.loc”,array(“persist”=>”t”)); #持久连接 //$conn=new Mongo(“mongodb://sa:123@localhost”); #带用户名密码 //$conn=new Mongo(“mongodb://localhost:27017,localhost:27018″); #连接多个服务器 //$conn=new Mongo(“mongodb:///tmp/mongo-27017.sock”); #域套接字 //$conn=new Mongo(“mongodb://admin_miss:miss@localhost:27017/test”,array(‘persist’=>’p',”replicaSet”=>true)); #完整 //详细资料:http://www.php.net/manual/en/mongo.connecting.php //************************* //** 选择数据库与表 **// //************************* $db=$conn->mydb; #选择mydb数据库 //$db=$conn->selectDB(“mydb”); #第二种写法 $collection=$db->column; #选择集合(选择’表’) //$collection=$db->selectCollection(‘column’); #第二种写法 //$collection=$conn->mydb->column; #更简洁的写法 //注意:1.数据库和集合不需要事先创建,若它们不存在则会自动创建它们. // 2.注意错别字,你可能会无意间的创建一个新的数据库(与原先的数据库混乱). //************************* //** 插入文档 **// //************************* //**向集合中插入数据,返回bool判断是否插入成功. **/ $array=array(‘column_name’=>’col’.rand(100,999),’column_exp’=>’xiaocai’); $result=$collection->insert($array); #简单插入 echo “新记录ID:”.$array['_id']; #MongoDB会返回一个记录标识 var_dump($result); #返回:bool(true) //**向集合中安全插入数据,返回插入状态(数组). **/ $array=array(‘column_name’=>’col’.rand(100,999),’column_exp’=>’xiaocai2′); $result=$collection->insert($array,true); #用于等待MongoDB完成操作,以便确定是否成功.(当有大量记录插入时使用该参数会比较有用) echo “新记录ID:”.$array['_id']; #MongoDB会返回一个记录标识 var_dump($result); #返回:array(3) { ["err"]=> NULL ["n"]=> int(0) ["ok"]=> float(1) } //**完整的写法 **/ #insert($array,array(‘safe’=>false,’fsync’=>false,’timeout’=>10000)) /* * * * 完整格式:insert ( array $a [, array $options = array() ] ) * insert(array(),array(‘safe’=>false,’fsync’=>false,’timeout’=>10000)) * 参数:safe:默认false,是否安全写入 * fsync:默认false,是否强制插入到同步到磁盘 * timeout:超时时间(毫秒) * * 插入结果:{ “_id” : ObjectId(“4d63552ad549a02c01000009″), “column_name” : “col770″, “column_exp” : “xiaocai” } * ’_id’为主键字段,在插入是MongoDB自动添加. * * 注意:1.以下两次插入的为同一条记录(相同的_id),因为它们的值相同。 * $collection->insert(array(‘column_name’=>’xiaocai’)); * $collection->insert(array(‘column_name’=>’xiaocai’)); * 避免 * $collection->insert(array(‘column_name’=>’xiaocai’),true); * try { * $collection->insert(array(‘column_name’=>’xiaocai’),true); * }catch(MongoCursorException $e){ * echo “Can’t save the same person twice!\n”; * } * * 详细资料:http://www.php.net/manual/zh/mongocollection.insert.php * * */ //************************* //** 更新文档 **// //************************* //** 修改更新 **/ $where=array(‘column_name’=>’col123′); $newdata=array(‘column_exp’=>’GGGGGGG’,'column_fid’=>444); $result=$collection->update($where,array(‘$set’=>$newdata)); #$set:让某节点等于给定值,类似的还有$pull $pullAll $pop $inc,在后面慢慢说明用法 /* * 结果: * 原数据 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_name”:”col123″,”column_exp”:”xiaocai”} * 被替换成了 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_name”:”col123″,”column_exp”:”GGGGGGG”,”column_fid”:444} */ //** 替换更新 **/ $where=array(‘column_name’=>’col709′); $newdata=array(‘column_exp’=>’HHHHHHHHH’,'column_fid’=>123); $result=$collection->update($where,$newdata); /* * 结果: * 原数据 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_name”:”col709″,”column_exp”:”xiaocai”} * 被替换成了 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_exp”:”HHHHHHHHH”,”column_fid”:123} */ //** 批量更新 **/ $where=array(‘column_name’=>’col’); $newdata=array(‘column_exp’=>’multiple’,’91u’=>684435); $result=$collection->update($where,array(‘$set’=>$newdata),array(‘multiple’=>true)); /** * 所有’column_name’='col’都被修改 */ //** 自动累加 **/ $where=array(’91u’=>684435); $newdata=array(‘column_exp’=>’edit’); $result=$collection->update($where,array(‘$set’=>$newdata,’$inc’=>array(’91u’=>-5))); /** * 更新91u=684435的数据,并且91u自减5 */ /** 删除节点 **/ $where=array(‘column_name’=>’col685′); $result=$collection->update($where,array(‘$unset’=>’column_exp’)); /** * 删除节点column_exp */ /* * * * 完整格式:update(array $criteria, array $newobj [, array $options = array() ] ) * 注意:1.注意区分替换更新与修改更新 * 2.注意区分数据类型如 array(’91u’=>’684435′)与array(’91u’=>684435) * 详细资料:http://www.mongodb.org/display/DOCS/Updating#Updating-%24bit * * */ //************************* //** 删除文档 **// //************************* /** 清空数据库 **/ $collection->remove(array(‘column_name’=>’col399′)); //$collection->remove(); #清空集合 /** 删除指定MongoId **/ $id = new MongoId(“4d638ea1d549a02801000011″); $collection->remove(array(‘_id’=>(object)$id)); /* * * * 使用下面的方法来匹配{“_id”:ObjectId(“4d638ea1d549a02801000011″)},查询、更新也一样 * $id = new MongoId(“4d638ea1d549a02801000011″); * array(‘_id’=>(object)$id) * * */ //************************* //** 查询文档 **// //************************* /** 查询文档中的记录数 **/ echo ‘count:’.$collection->count().”
”; #全部 echo ‘count:’.$collection->count(array(‘type’=>’user’)).”
”; #可以加上条件 echo ‘count:’.$collection->count(array(‘age’=>array(‘$gt’=>50,’$lte’=>74))).”
”; #大于50小于等于74 echo ‘count:’.$collection->find()->limit(5)->skip(0)->count(true).”
”; #获得实际返回的结果数 /** * 注:$gt为大于、$gte为大于等于、$lt为小于、$lte为小于等于、$ne为不等于、$exists不存在 */ /** 集合中所有文档 **/ $cursor = $collection->find()->snapshot(); foreach ($cursor as $id => $value) { echo “$id: “; var_dump($value); echo “
”; } /** * 注意: * 在我们做了find()操作,获得$cursor游标之后,这个游标还是动态的. * 换句话说,在我find()之后,到我的游标循环完成这段时间,如果再有符合条件的记录被插入到collection,那么这些记录也会被$cursor 获得. * 如果你想在获得$cursor之后的结果集不变化,需要这样做: * $cursor = $collection->find(); * $cursor->snapshot(); * 详见http://www.bumao.com/index.php/2010/08/mongo_php_cursor.html */ /** 查询一条数据 **/ $cursor = $collection->findOne(); /** * 注意:findOne()获得结果集后不能使用snapshot(),fields()等函数; */ /** age,type 列不显示 **/ $cursor = $collection->find()->fields(array(“age”=>false,”type”=>false)); /** 只显示user 列 **/ $cursor = $collection->find()->fields(array(“user”=>true)); /** * 我这样写会出错:$cursor->fields(array(“age”=>true,”type”=>false)); */ /** (存在type,age节点) and age!=0 and age<50 **/ $where=array(‘type’=>array(‘$exists’=>true),’age’=>array(‘$ne’=>0,’$lt’=>50,’$exists’=>true)); $cursor = $collection->find($where); /** 分页获取结果集 **/ $cursor = $collection->find()->limit(5)->skip(0); /** 排序 **/ $cursor = $collection->find()->sort(array(‘age’=>-1,’type’=>1)); ##1表示降序 -1表示升序,参数的先后影响排序顺序 /** 索引 **/ $collection->ensureIndex(array(‘age’ => 1,’type’=>-1)); #1表示降序 -1表示升序 $collection->ensureIndex(array(‘age’ => 1,’type’=>-1),array(‘background’=>true)); #索引的创建放在后台运行(默认是同步运行) $collection->ensureIndex(array(‘age’ => 1,’type’=>-1),array(‘unique’=>true)); #该索引是唯一的 /** * ensureIndex (array(),array(‘name’=>’索引名称’,'background’=true,’unique’=true)) * 详见:http://www.php.net/manual/en/mongocollection.ensureindex.php */ /** 取得查询结果 **/ $cursor = $collection->find(); $array=array(); foreach ($cursor as $id => $value) { $array[]=$value; } //************************* //** 文档聚类 **// //************************* //这东西没弄明白… $conn->close(); #关闭连接 /* 关系型数据库与MongoDB数据存储的区别 MySql数据结构: CREATE TABLE IF NOT EXISTS `column`( `column_id` int(16) NOT NULL auto_increment COMMENT ‘主键’, `column_name` varchar(32) NOT NULL COMMENT ‘栏目名称’, PRIMARY KEY (`column_id`) ); CREATE TABLE IF NOT EXISTS `article`( `article_id` int(16) NOT NULL auto_increment COMMENT ‘主键’, `article_caption` varchar(15) NOT NULL COMMENT ‘标题’, PRIMARY KEY(`article_id`) ); CREATE TABLE IF NOT EXISTS `article_body`( `article_id` int(16) NOT NULL COMMENT ‘article.article_id’, `body` text COMMENT ‘正文’ ); MongoDB数据结构: $data=array( ‘column_name’ =>’default’, ‘article’ =>array( ‘article_caption’ => ‘xiaocai’, ‘body’ => ‘xxxxxxxxxx…’ ) ); $inc 如果记录的该节点存在,让该节点的数值加N;如果该节点不存在,让该节点值等于N 设结构记录结构为 array(’a’=>1,’b’=>’t’),想让a加5,那么: $coll->update( array(’b’=>’t’), array(’$inc’=>array(’a’=>5)), ) $set 让某节点等于给定值 设结构记录结构为 array(’a’=>1,’b’=>’t’),b为加f,那么: $coll->update( array(’a’=>1), array(’$set’=>array(’b’=>’f’)), ) $unset 删除某节点 设记录结构为 array(’a’=>1,’b’=>’t’),想删除b节点,那么: $coll->update( array(’a’=>1), array(’$unset’=>’b’), ) $push 如果对应节点是个数组,就附加一个新的值上去;不存在,就创建这个数组,并附加一个值在这个数组上;如果该节点不是数组,返回错误。 设记录结构为array(’a’=>array(0=>’haha’),’b’=& gt;1),想附加新数据到节点a,那么: $coll->update( array(’b’=>1), array(’$push’=>array(’a’=>’wow’)), ) 这样,该记录就会成为:array(’a’=>array(0=>’haha’,1=>’wow’),’b’=>1) $pushAll 与$push类似,只是会一次附加多个数值到某节点 $addToSet 如果该阶段的数组中没有某值,就添加之 设记录结构为array(’a’=>array(0=& gt;’haha’),’b’=>1),如果想附加新的数据到该节点a,那么: $coll->update( array(’b’=>1), array(’$addToSet’=>array(’a’=>’wow’)), ) 如果在a节点中已经有了wow,那么就不会再添加新的,如果没有,就会为该节点添加新的item——wow。 $pop 设该记录为array(’a’=>array(0=>’haha’,1=& gt;’wow’),’b’=>1) 删除某数组节点的最后一个元素: $coll->update( array(’b’=>1), array(’$pop=>array(’a’=>1)), ) 删除某数组阶段的第一个元素 $coll->update( array(’b’=>1), array(’$pop=>array(’a’=>-1)), ) $pull 如果该节点是个数组,那么删除其值为value的子项,如果不是数组,会返回一个错误。 设该记录为 array(’a’=>array(0=>’haha’,1=>’wow’),’b’=>1),想要删除a中value为 haha的子项: $coll->update( array(’b’=>1), array(’$pull=>array(’a’=>’haha’)), ) 结果为: array(’a’=>array(0=>’wow’),’b’=>1) $pullAll 与$pull类似,只是可以删除一组符合条件的记录。 */ ?> (“mongodb://用户名:密码 @地址:端口/默认指定数据库”,参数) $conn = new Mongo(); //可以简写为 //$conn=new Mongo(); #连接本地主机,默认端口. //$conn=new Mongo(“172.21.15.69″); #连接远程主机 //$conn=new Mongo(“xiaocai.loc:10086″); #连接指定端口远程主机 //$conn=new Mongo(“xiaocai.loc”,array(“replicaSet”=>true)); #负载均衡 //$conn=new Mongo(“xiaocai.loc”,array(“persist”=>”t”)); #持久连接 //$conn=new Mongo(“mongodb://sa:123@localhost”); #带用户名密码 //$conn=new Mongo(“mongodb://localhost:27017,localhost:27018″); #连接多个服务器 //$conn=new Mongo(“mongodb:///tmp/mongo-27017.sock”); #域套接字 //$conn=new Mongo(“mongodb://admin_miss:miss@localhost:27017/test”,array(‘persist’=>’p',”replicaSet”=>true)); #完整 //详细资料:http://www.php.net/manual/en/mongo.connecting.php //************************* //** 选择数据库与表 **// //************************* $db=$conn->mydb; #选择mydb数据库 //$db=$conn->selectDB(“mydb”); #第二种写法 $collection=$db->column; #选择集合(选择’表’) //$collection=$db->selectCollection(‘column’); #第二种写法 //$collection=$conn->mydb->column; #更简洁的写法 //注意:1.数据库和集合不需要事先创建,若它们不存在则会自动创建它们. // 2.注意错别字,你可能会无意间的创建一个新的数据库(与原先的数据库混乱). //************************* //** 插入文档 **// //************************* //**向集合中插入数据,返回bool判断是否插入成功. **/ $array=array(‘column_name’=>’col’.rand(100,999),’column_exp’=>’xiaocai’); $result=$collection->insert($array); #简单插入 echo “新记录ID:”.$array['_id']; #MongoDB会返回一个记录标识 var_dump($result); #返回:bool(true) //**向集合中安全插入数据,返回插入状态(数组). **/ $array=array(‘column_name’=>’col’.rand(100,999),’column_exp’=>’xiaocai2′); $result=$collection->insert($array,true); #用于等待MongoDB完成操作,以便确定是否成功.(当有大量记录插入时使用该参数会比较有用) echo “新记录ID:”.$array['_id']; #MongoDB会返回一个记录标识 var_dump($result); #返回:array(3) { ["err"]=> NULL ["n"]=> int(0) ["ok"]=> float(1) } //**完整的写法 **/ #insert($array,array(‘safe’=>false,’fsync’=>false,’timeout’=>10000)) /* * * * 完整格式:insert ( array $a [, array $options = array() ] ) * insert(array(),array(‘safe’=>false,’fsync’=>false,’timeout’=>10000)) * 参数:safe:默认false,是否安全写入 * fsync:默认false,是否强制插入到同步到磁盘 * timeout:超时时间(毫秒) * * 插入结果:{ “_id” : ObjectId(“4d63552ad549a02c01000009″), “column_name” : “col770″, “column_exp” : “xiaocai” } * ’_id’为主键字段,在插入是MongoDB自动添加. * * 注意:1.以下两次插入的为同一条记录(相同的_id),因为它们的值相同。 * $collection->insert(array(‘column_name’=>’xiaocai’)); * $collection->insert(array(‘column_name’=>’xiaocai’)); * 避免 * $collection->insert(array(‘column_name’=>’xiaocai’),true); * try { * $collection->insert(array(‘column_name’=>’xiaocai’),true); * }catch(MongoCursorException $e){ * echo “Can’t save the same person twice!\n”; * } * * 详细资料:http://www.php.net/manual/zh/mongocollection.insert.php * * */ //************************* //** 更新文档 **// //************************* //** 修改更新 **/ $where=array(‘column_name’=>’col123′); $newdata=array(‘column_exp’=>’GGGGGGG’,'column_fid’=>444); $result=$collection->update($where,array(‘$set’=>$newdata)); #$set:让某节点等于给定值,类似的还有$pull $pullAll $pop $inc,在后面慢慢说明用法 /* * 结果: * 原数据 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_name”:”col123″,”column_exp”:”xiaocai”} * 被替换成了 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_name”:”col123″,”column_exp”:”GGGGGGG”,”column_fid”:444} */ //** 替换更新 **/ $where=array(‘column_name’=>’col709′); $newdata=array(‘column_exp’=>’HHHHHHHHH’,'column_fid’=>123); $result=$collection->update($where,$newdata); /* * 结果: * 原数据 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_name”:”col709″,”column_exp”:”xiaocai”} * 被替换成了 * {“_id”:ObjectId(“4d635ba2d549a02801000003″),”column_exp”:”HHHHHHHHH”,”column_fid”:123} */ //** 批量更新 **/ $where=array(‘column_name’=>’col’); $newdata=array(‘column_exp’=>’multiple’,’91u’=>684435); $result=$collection->update($where,array(‘$set’=>$newdata),array(‘multiple’=>true)); /** * 所有’column_name’='col’都被修改 */ //** 自动累加 **/ $where=array(’91u’=>684435); $newdata=array(‘column_exp’=>’edit’); $result=$collection->update($where,array(‘$set’=>$newdata,’$inc’=>array(’91u’=>-5))); /** * 更新91u=684435的数据,并且91u自减5 */ /** 删除节点 **/ $where=array(‘column_name’=>’col685′); $result=$collection->update($where,array(‘$unset’=>’column_exp’)); /** * 删除节点column_exp */ /* * * * 完整格式:update(array $criteria, array $newobj [, array $options = array() ] ) * 注意:1.注意区分替换更新与修改更新 * 2.注意区分数据类型如 array(’91u’=>’684435′)与array(’91u’=>684435) * 详细资料:http://www.mongodb.org/display/DOCS/Updating#Updating-%24bit * * */ //************************* //** 删除文档 **// //************************* /** 清空数据库 **/ $collection->remove(array(‘column_name’=>’col399′)); //$collection->remove(); #清空集合 /** 删除指定MongoId **/ $id = new MongoId(“4d638ea1d549a02801000011″); $collection->remove(array(‘_id’=>(object)$id)); /* * * * 使用下面的方法来匹配{“_id”:ObjectId(“4d638ea1d549a02801000011″)},查询、更新也一样 * $id = new MongoId(“4d638ea1d549a02801000011″); * array(‘_id’=>(object)$id) * * */ //************************* //** 查询文档 **// //************************* /** 查询文档中的记录数 **/ echo ‘count:’.$collection->count().”
”; #全部 echo ‘count:’.$collection->count(array(‘type’=>’user’)).”
”; #可以加上条件 echo ‘count:’.$collection->count(array(‘age’=>array(‘$gt’=>50,’$lte’=>74))).”
”; #大于50小于等于74 echo ‘count:’.$collection->find()->limit(5)->skip(0)->count(true).”
”; #获得实际返回的结果数 /** * 注:$gt为大于、$gte为大于等于、$lt为小于、$lte为小于等于、$ne为不等于、$exists不存在 */ /** 集合中所有文档 **/ $cursor = $collection->find()->snapshot(); foreach ($cursor as $id => $value) { echo “$id: “; var_dump($value); echo “
”; } /** * 注意: * 在我们做了find()操作,获得$cursor游标之后,这个游标还是动态的. * 换句话说,在我find()之后,到我的游标循环完成这段时间,如果再有符合条件的记录被插入到collection,那么这些记录也会被$cursor 获得. * 如果你想在获得$cursor之后的结果集不变化,需要这样做: * $cursor = $collection->find(); * $cursor->snapshot(); * 详见http://www.bumao.com/index.php/2010/08/mongo_php_cursor.html */ /** 查询一条数据 **/ $cursor = $collection->findOne(); /** * 注意:findOne()获得结果集后不能使用snapshot(),fields()等函数; */ /** age,type 列不显示 **/ $cursor = $collection->find()->fields(array(“age”=>false,”type”=>false)); /** 只显示user 列 **/ $cursor = $collection->find()->fields(array(“user”=>true)); /** * 我这样写会出错:$cursor->fields(array(“age”=>true,”type”=>false)); */ /** (存在type,age节点) and age!=0 and age<50 **/ $where=array(‘type’=>array(‘$exists’=>true),’age’=>array(‘$ne’=>0,’$lt’=>50,’$exists’=>true)); $cursor = $collection->find($where); /** 分页获取结果集 **/ $cursor = $collection->find()->limit(5)->skip(0); /** 排序 **/ $cursor = $collection->find()->sort(array(‘age’=>-1,’type’=>1)); ##1表示降序 -1表示升序,参数的先后影响排序顺序 /** 索引 **/ $collection->ensureIndex(array(‘age’ => 1,’type’=>-1)); #1表示降序 -1表示升序 $collection->ensureIndex(array(‘age’ => 1,’type’=>-1),array(‘background’=>true)); #索引的创建放在后台运行(默认是同步运行) $collection->ensureIndex(array(‘age’ => 1,’type’=>-1),array(‘unique’=>true)); #该索引是唯一的 /** * ensureIndex (array(),array(‘name’=>’索引名称’,'background’=true,’unique’=true)) * 详见:http://www.php.net/manual/en/mongocollection.ensureindex.php */ /** 取得查询结果 **/ $cursor = $collection->find(); $array=array(); foreach ($cursor as $id => $value) { $array[]=$value; } //************************* //** 文档聚类 **// //************************* //这东西没弄明白… $conn->close(); #关闭连接 /* 关系型数据库与MongoDB数据存储的区别 MySql数据 结构: CREATE TABLE IF NOT EXISTS `column`( `column_id` int(16) NOT NULL auto_increment COMMENT ‘主键’, `column_name` varchar(32) NOT NULL COMMENT ‘栏目名称’, PRIMARY KEY (`column_id`) ); CREATE TABLE IF NOT EXISTS `article`( `article_id` int(16) NOT NULL auto_increment COMMENT ‘主键’, `article_caption` varchar(15) NOT NULL COMMENT ‘标题’, PRIMARY KEY(`article_id`) ); CREATE TABLE IF NOT EXISTS `article_body`( `article_id` int(16) NOT NULL COMMENT ‘article.article_id’, `body` text COMMENT ‘正文’ ); MongoDB数据结构: $data=array( ‘column_name’ =>’default’, ‘article’ =>array( ‘article_caption’ => ‘xiaocai’, ‘body’ => ‘xxxxxxxxxx…’ ) ); $inc 如果记录的该节点存在,让该节点的数值加N;如果该节点不存在,让该节点值等 于N 设结构记录结构为 array(’a’=>1,’b’=>’t’),想让a加5,那么: $coll->update( array(’b’=>’t’), array(’$inc’=>array(’a’=>5)), ) $set 让某节点等于给定值 设结构记录结构为 array(’a’=>1,’b’=>’t’),b为加f,那么: $coll->update( array(’a’=>1), array(’$set’=>array(’b’=>’f’)), ) $unset 删除某节点 设记录结构为 array(’a’=>1,’b’=>’t’),想删除b节点,那么: $coll->update( array(’a’=>1), array(’$unset’=>’b’), ) $push 如果对应节点是个数组,就附加一个新的值上去;不存在,就创建这个数组,并附加一个值在这个数组上;如果 该节点不是数组,返回错误。 设记录结构为array(’a’=>array(0=>’haha’),’b’=& gt;1),想附加新数据到节点a,那么: $coll->update( array(’b’=>1), array(’$push’=>array(’a’=>’wow’)), ) 这 样,该记录就会成为:array(’a’=>array(0=>’haha’,1=>’wow’),’b’=>1) $pushAll 与$push类似,只是会一次附加多个数值到某节点 $addToSet 如果该阶段的数组中没有某值,就添加之 设记录结构为array(’a’=>array(0=& gt;’haha’),’b’=>1),如果想附加新的数据到该节点a,那么: $coll->update( array(’b’=>1), array(’$addToSet’=>array(’a’=>’wow’)), ) 如果在a节点中已经有了wow,那么就不会再添加新的,如果没有,就会为该节点添加新的item——wow。 $pop 设该记录为array(’a’=>array(0=>’haha’,1=& gt;’wow’),’b’=>1) 删除某数组节点的最后一个元素: $coll->update( array(’b’=>1), array(’$pop=>array(’a’=>1)), ) 删除某数组阶段的第一个元素 $coll->update( array(’b’=>1), array(’$pop=>array(’a’=>-1)), ) $pull 如果该节点是个数组,那么删除其值为value的子项,如果不是数组,会返回一个错误。 设该记录为 array(’a’=>array(0=>’haha’,1=>’wow’),’b’=>1),想要删除a中value为 haha的子项: $coll->update( array(’b’=>1), array(’$pull=>array(’a’=>’haha’)), ) 结 果为: array(’a’=>array(0=>’wow’),’b’=>1) $pullAll 与$pull类似,只是可以删除一组符合条件的记录。 */ ?>

memcached常见命令

1、启动Memcache 常用参数 -p <num>      设置端口号(默认不设置为: 11211) -U <num>      UDP监听端口(默认: 11211, 0 时关闭) -l <ip_addr>  绑定地址(默认:所有都允许,无论内外网或者本机更换IP,有安全隐患,若设置为127.0.0.1就只能本机访问) -d            独立进程运行 -u <username> 绑定使用指定用于运行进程<username> -m <num>      允许最大内存用量,单位M (默认: 64 MB) -P <file>     将PID写入文件<file>,这样可以使得后边进行快速进程终止, 需要与-d 一起使用 如: 在linux下:./usr/local/bin/memcached -d -u jb-mc -l 192.168.1.197 -m 2048 -p 12121 在window下:d:\App_Serv\memcached\memcached.exe -d RunService -l 127.0.0.1 -p 11211 -m 500 在windows下注册为服务后运行: sc.exe create jb-Memcached binpath= “d:\App_Serv\memcached\memcached.exe -d RunService -p 11211 -m 500″start= auto net start jb-Memcached 2、连接:telnet 127.0.0.1 11211 3、您将使用五种基本memcached 命令执行最简单的操作。这些命令和操作包括: set: 用于向缓存添加新的键值对。如果键已经存在,则之前的值将被替换。 add :仅当缓存中不存在键时,add 命令才会向缓存中添加一个键值对。如果缓存中已经存在键,则之前的值将仍然保持相同,并且您将获得响应NOT_STORED 。 replace:仅当键已经存在时,replace 命令才会替换缓存中的键。如果缓存中不存在键,那么您将从memcached 服务器接受到一条NOT_STORED 响应。 get:用于检索与之前添加的键值对相关的值。 delete:用于删除memcached 中的任何现有值。您将使用一个键调用delete ,如果该键存在于缓存中,则删除该值。如果不存在,则返回一条NOT_FOUND 消息。 gets:功能类似于基本的get 命令。两个命令之间的差异在于,gets 返回的信息稍微多一些:64 位的整型值非常像名称/值对的 “版本” 标识符。 前三个命令是用于操作存储在memcached 中的键值对的标准修改命令。它们都非常简单易用,且都使用清单5 所示的语法: command <key> <flags> <expiration time> <bytes> <value> 表1. memcached 修改命令参数 参数       用法 key  key 用于查找缓存值 flags       可以包括键值对的整型参数,客户机使用它存储关于键值对的额外信息 expiration time       在缓存中保存键值对的时间长度(以秒为单位,0 表示永远) bytes       在缓存中存储的字节点 value       存储的值(始终位于第二行) 例子: set useID 0 0 5 1234 4、缓存管理命令 最后两个memcached 命令用于监控和清理memcached 实例。它们是stats 和flush_all 命令。 stats :转储所连接的memcached 实例的当前统计数据。 flush_all:用于清理缓存中的所有名称/值对。如果您需要将缓存重置到干净的状态,则flush_all 能提供很大的用处。 查看memcached状态的基本命令,通过这个命令可以看到如下信息: STAT pid 22459                             进程ID STAT uptime 1027046                        服务器运行秒数 STAT time 1273043062                       服务器当前unix时间戳 STAT version 1.4.4                         服务器版本 STAT pointer_size 64                       操作系统字大小(这台服务器是64位的) STAT rusage_user 0.040000                  进程累计用户时间 STAT rusage_system 0.260000                进程累计系统时间 STAT curr_connections 10                   当前打开连接数 STAT total_connections 82                  曾打开的连接总数 STAT connection_structures 13              服务器分配的连接结构数 STAT cmd_get 54                            执行get命令总数 STAT cmd_set 34                            执行set命令总数 STAT cmd_flush 3                           指向flush_all命令总数 STAT get_hits 9                            get命中次数 STAT get_misses 45                         get未命中次数 STAT delete_misses 5                       delete未命中次数 STAT delete_hits 1                         delete命中次数 STAT incr_misses 0                         incr未命中次数 STAT incr_hits 0                           incr命中次数 STAT decr_misses 0                         decr未命中次数 STAT decr_hits 0                           decr命中次数 STAT cas_misses 0    cas未命中次数 STAT cas_hits 0                            cas命中次数 STAT cas_badval 0                          使用擦拭次数 STAT auth_cmds 0 STAT auth_errors 0 STAT bytes_read 15785                      读取字节总数 STAT bytes_written 15222                   写入字节总数 STAT limit_maxbytes 1048576                分配的内存数(字节) STAT accepting_conns 1                     目前接受的链接数 STAT listen_disabled_num 0 STAT threads 4                             线程数 STAT conn_yields 0 STAT bytes 0                               存储item字节数 STAT curr_items 0                          item个数 STAT total_items 34                        item总数 STAT evictions 0                           为获取空间删除item的总数

在Linux上安装Memcached服务

下载并安装Memcache服务器端 服务器端主要是安装memcache服务器端. 下载:http://www.danga.com/memcached/dist/memcached-1.2.2.tar.gz 另外,Memcache用到了libevent这个库用于Socket的处理,所以还需要安装libevent,libevent的最新版本是libevent-1.3。(如果你的系统已经安装了libevent,可以不用安装) 官网:http://www.monkey.org/~provos/libevent/ 下载:http://www.monkey.org/~provos/libevent-1.3.tar.gz 用wget指令直接下载这两个东西.下载回源文件后。 1.先安装libevent。这个东西在配置时需要指定一个安装路径,即./configure –prefix=/usr;然后make;然后make install; 2.再安装memcached,只是需要在配置时需要指定libevent的安装路径即./configure –with-libevent=/usr;然后make;然后make install; 这样就完成了Linux下Memcache服务器端的安装。详细的方法如下: 1.分别把memcached和libevent下载回来,放到 /tmp 目录下: # cd /tmp # wget http://www.danga.com/memcached/dist/memcached-1.2.0.tar.gz # wget http://www.monkey.org/~provos/libevent-1.2.tar.gz 2.先安装libevent: # tar zxvf libevent-1.2.tar.gz # cd libevent-1.2 # ./configure –prefix=/usr # make # make install 3.测试libevent是否安装成功: # ls -al /usr/lib | grep libevent lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent-1.2.so.1 -> libevent-1.2.so.1.0.3 -rwxr-xr-x 1 root root 263546 11?? 12 17:38 libevent-1.2.so.1.0.3 -rw-r–r– 1 root root 454156 11?? 12 17:38 libevent.a -rwxr-xr-x 1 root root 811 11?? 12 17:38 libevent.la lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent.so -> libevent-1.2.so.1.0.3 还不错,都安装上了。 4.安装memcached,同时需要安装中指定libevent的安装位置: # cd /tmp # tar zxvf memcached-1.2.0.tar.gz # cd memcached-1.2.0 # ./configure –with-libevent=/usr # make # make install 如果中间出现报错,请仔细检查错误信息,按照错误信息来配置或者增加相应的库或者路径。 安装完成后会把memcached放到 /usr/local/bin/memcached , 5.测试是否成功安装memcached: # ls -al /usr/local/bin/mem* -rwxr-xr-x 1 root root 137986 11?? 12 17:39 /usr/local/bin/memcached -rwxr-xr-x 1 root root 140179 11?? 12 17:39 /usr/local/bin/memcached-debug 启动Memcached服务: 1.启动Memcache的服务器端: # /usr/local/bin/memcached -d -m 10 -u root -l 192.168.141.64 -p 12000 -c 256 -P /tmp/memcached.pid -d选项是启动一个守护进程, -m是分配给Memcache使用的内存数量,单位是MB,我这里是10MB, -u是运行Memcache的用户,我这里是root, -l是监听的服务器IP地址,如果有多个地址的话,我这里指定了服务器的IP地址192.168.0.200, -p是设置Memcache监听的端口,我这里设置了12000,最好是1024以上的端口, -c选项是最大运行的并发连接数,默认是1024,我这里设置了256,按照你服务器的负载量来设定, -P是设置保存Memcache的pid文件,我这里是保存在 /tmp/memcached.pid, 2.如果要结束Memcache进程,执行:
# kill `cat /tmp/memcached.pid`
也可以启动多个守护进程,不过端口不能重复。 测试Memcached:
复制代码
[root@localhost /]# telnet 192.168.141.64 12000 Trying 192.168.141.64... Connected to 192.168.141.64 (192.168.141.64). Escape character is '^]'. set key1 0 60 4 zhou STORED get key1 VALUE key1 0 4 zhou END
复制代码
至此Memcached安装成功! 常见问题: 1.如果启动Memcached服务的时候遇到了 /usr/local/bin/memcached: error while loading shared libraries: libevent-1.2.so.1: cannot open shared object file: No such file or directory; 解决方案:
[root@localhost bin]# LD_DEBUG=libs memcached -v [root@localhost bin]# ln -s /usr/lib/libevent-1.2.so.1 /usr/lib64/libevent-1.2.so.1 [root@localhost bin]# /usr/local/bin/memcached -d -m 100 -u root -p 12000 -c 1000 -P /tmp/memcached.pid [root@localhost bin]# ps -aux
可以看到启动的Memcached服务了. 2.把Memcached服务加载到Linux的启动项中.万一机器断电系统重启.那么Memcached就会自动启动了. 假如启动Memcache的服务器端的命令为: # /usr/local/bin/memcached -d -m 10 -u root -l 192.168.141.64 -p 12000 -c 256 -P /tmp/memcached.pid容来自17jquery 想开机自动启动的话,只需在/etc/rc.d/rc.local中加入一行,下面命令 /usr/local/memcached/bin/memcached -d -m 10 -p 12000 -u apache -c 256 上面有些东西可以参考一下:即,ip不指定时,默认是本机,用户:最好选择是:apache 或 deamon 这样,也就是属于哪个用户的服务,由哪个用户启动。 原文 http://www.cnblogs.com/zgx/archive/2011/08/10/2134097.html

mongodo 权限认证

1. 在开启MongoDB 服务时不添加任何参数时,可以对数据库任意操作,而且可以远程访问数据库。如果启动的时候指定—auth参数,可以对数据库进行用户验证            $ ./mongod --auth >> mongodb.log & 开启            ./mongo MongoDB shell version: 1.8.1 connecting to: test >show dbs admin   (empty) local   (empty)

2. 添加用户

在刚安装完毕的时候MongoDB都默认有一个admin数据库,而admin.system.users中将会保存比在其它数据库中设置的用户权限更大的用户信息。

当admin.system.users中一个用户都没有时,即使mongod启动时添加了--auth参数,如果没有在admin数据库中添加用户,此时不进行任何认证还是可以做任何操作,直到在admin.system.users中添加了一个用户。 下面创建数据库tage,并给tage创建用户: > use tage    switched to db tage > db.addUser("tage","123") {          "user" : "tage",          "readOnly" : false,          "pwd" : "1f66d5c4223029536080d41febe0ec33" } 在admin库中创建root用户: > use admin switched to db admin > db.addUser("root","123456") {          "user" : "root",          "readOnly" : false,          "pwd" : "34e5772aa66b703a319641d42a47d696" } 3. 验证用户: > db.auth("root","123") 0                    密码错误,返回0,验证失败 > db.auth("root","123456")   1                                            验证成功,返回1   下面试验用户权限设置: $ ./mongo       登录时不加用户名与密码 MongoDB shell version: 1.8.1 connecting to: test > use tage switched to db tage > db.system.users.find() error: {          "$err" : "unauthorized db:tage lock type:-1 client:127.0.0.1",          "code" : 10057 } 4. 以上验证说明,登录时不指定用户名与密码,就会报错。下面指定用户与密码 $ ./mongo -uroot -p123456  指定用户与密码,但是不指定库名 MongoDB shell version: 1.8.1 connecting to: test Wed Aug  3 21:30:42 uncaught exception: login failed exception: login failed mongodb登录时默认连接test库,如果登录时不指定库名,就会报错 5. 下面以tage库的用户名登录进行验证: $ ./mongo tage -utage -p123 MongoDB shell version: 1.8.1 connecting to: tage > db.system.users.find()    对所属自己的库进行操作,有权限 { "_id" : ObjectId("4e394c696b50a56254359088"), "user" : "tage", "readOnly" : false, "pwd" : "1f66d5c4223029536080d41febe0ec33" } > use admin switched to db admin > db.system.users.find() 对其他库操作,没有权限 error: {          "$err" : "unauthorized db:admin lock type:-1 client:127.0.0.1",          "code" : 10057 } 6. 下面以admin库下的root用户登录进行验证: ./mongo admin -uroot -p123456 MongoDB shell version: 1.8.1 connecting to: admin > db.system.users.find() { "_id" : ObjectId("4e394caf6b50a56254359089"), "user" : "root", "readOnly" : false, "pwd" : "34e5772aa66b703a319641d42a47d696" } > use tage switched to db tage > db.system.users.find()   对其他库进行操作,有权限 { "_id" : ObjectId("4e394c696b50a56254359088"), "user" : "tage", "readOnly" : false, "pwd" : "1f66d5c4223029536080d41febe0ec33" } 7. mongodb的远程用户连接 语法结构:mongo –uusername –ppwd ServerIP:port/dbname 其中port默认为27017 $ ./mongo  -uroot -p123456 192.168.2.150/admin MongoDB shell version: 1.8.1 connecting to: 192.168.2.150/admin > db.system.users.find() { "_id" : ObjectId("4e394caf6b50a56254359089"), "user" : "root", "readOnly" : false, "pwd" : "34e5772aa66b703a319641d42a47d696" }