Java & Game » 数据库 http://www.javagg.com java&j2me Sat, 02 Jul 2011 08:59:18 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 开源面向对象数据库 db4o 之旅: 深入db4o http://www.javagg.com/archives/774 http://www.javagg.com/archives/774#comments Fri, 14 May 2010 02:22:50 +0000 纯净水 http://www.javagg.com/?p=774 前言

在开源面向对象数据库 db4o 之旅 系列文章的第 1 部分：初识 db4o 中，作者介绍了 db4o 的历史和现状，应用领域，以及和 ORM 等的比较； 在第 2 部分：db4o 查询方式中, 作者介绍了 db4o 的三种不同的查询方式：QBE、SODA 以及 Native Queries，并分别通过这三种不同的途径实现了两个关联对象的查询。

前面我们已经介绍了如何在 db4o 中查询以及添加对象，在本文中我们将会向您介绍在 db4o 中如何对对象进行更新以及删除操作。

更新数据

场景一

我们来设想这样的场景：一位名叫“张三”的人买了车，并上好了牌照（如本系列第二部分之代码），而他基本信息的地址并不详细，只写了“成都市”，在一次主管部门检查此人信息的时候，发现了这个问题，并立即着手修改。

在 db4o 中，我们这样来实现对这个用户信息的修改（清单1）：
清单1. 修改地址

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o.openFile("auto.yap");
  16.                 try{
  17.                         ObjectSet<People> result = db.query(new Predicate<People>() {
  18.                             public boolean match(People people) {
  19.                                 return people.getName().equals("张三");
  20.                             }
  21.                         });
  22.                         People people = result.next();
  23.                         //修改地址
  24.                         people.setAddress("成都市金牛区xxx号");
  25.                         db.set(people);
  26.                 }finally{
  27.                         //关闭连接
  28.                         db.close();
  29.                 }
  30.         }
  31. }

 

修改数据是如此的简单，通过 NQ 查询出 People 对象，接着修改其地址，最后保存即可。现在我们来看看修改是否成功, 打开 ObjectManager ，如图 1 所示，我们可以看到数据库里的用户数据已经更新了。
图1. 修改地址
图1. 修改地址

与本系列文章第二部分不同的是，我们利用 ObjectSet<People> result 来获取返回结果，而不是 List<People> list。查阅 ObjectSet 的 API 我们发现 ObjectSet 实际上继承了 java.util.List 和 java.util.Iterator。为什么要继承两个接口？这是由于 db4o 为了方便开发者而有意这样设计的，db4o 的设计目标就是轻量级，这样的继承方式为 ObjectSet 提供了多种特性，而无需开发者在多个集合接口之间转换。

场景二

让我们考虑下面这个场景:
由于工作原因，“张三”要离开省会去其他城市发展，他的汽车也要在那里使用，为了方便，他还是决定重新更换为本地牌照。

这次我们几乎和场景一采用同样的代码，但结果却不同（清单2）：
清单2. 修改地址和车牌（不成功）

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o.openFile("auto.yap");
  16.                 try{
  17.                         ObjectSet<People> result = db.query(new Predicate<People>() {
  18.                             public boolean match(People people) {
  19.                                 return people.getName().equals("张三");
  20.                             }
  21.                         });
  22.                         People people = result.next();
  23.                         //修改地址
  24.                         people.setAddress("绵阳市xx区xxx号");
  25.                         //修改车牌号
  26.                         people.getAutoInfoList().get(0).setLicensePlate("川B00000");
  27.                         db.set(people);
  28.                 }finally{
  29.                         //关闭连接
  30.                         db.close();
  31.                 }
  32.         }
  33. }

 

想必应该保存成功了吧，只是多加入了设置车牌的代码。打开 ObjectManager，如图 2 所示。很奇怪，地址保存成功了，而车牌却根本没变化。
图2. 修改地址和车牌（不成功）
图2. 修改地址和车牌（不成功）

其实这也是 db4o 的有意安排。设想一个复杂对象有很多成员，并且这些成员又有自己的成员。当更新该对象，db4o 将不得不更新其所有的关联对象、关联对象的关联对象，等等。这将引起严重的性能惩罚，而且在大部分的情况下是没有必要这样的。

db4o 引入了“更新深度(update depth)”这一概念来控制被更新的对象成员树深度。默认的更新深度是 1，这就意味着只有基本类型和 String 类型的成员变量可以被更新，而修改对象成员将得不到任何反映，例如本例中修改 People 对象的 _autoInfoList 成员。

为了能更新成员对象，ob4o 提供了 cascadeOnUpdate() 方法，该方法必须在每次开启数据库之前设置清单3：
清单3. 修改地址和车牌（成功）

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.         //级联设置
  15.                 Db4o.configure().objectClass("bo.People")
  16.         .cascadeOnUpdate(true);
  17.                 //打开数据库
  18.                 ObjectContainer db = Db4o.openFile("auto.yap");
  19.                 try{
  20.                         ObjectSet<People> result = db.query(new Predicate<People>() {
  21.                             public boolean match(People people) {
  22.                                 return people.getName().equals("张三");
  23.                             }
  24.                         });
  25.                         People people = result.next();
  26.                         //修改地址
  27.                         people.setAddress("绵阳市xx区xxx号");
  28.                         //修改车牌号
  29.                         people.getAutoInfoList().get(0).setLicensePlate("川B00000");
  30.                         db.set(people);
  31.                 }finally{
  32.                         //关闭连接
  33.                         db.close();
  34.                 }
  35.         }
  36. }

 

这下终于如愿以偿，如图 3 所示。其实 db4o 为开发者想得很周到，关键是如何用好这些特性。
图3. 修改地址和车牌（成功）
图3. 修改地址和车牌（成功）
删除数据

场景三

“张三”换了工作后，事业发展很快，准备把车卖了换新的，于是他去交管部门办理移交手续，删除关联的车辆信息清单4：
清单4. 删除车辆

  1.                                
  2. package com;
  3.  
  4. import bo.AutoInfo;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o.openFile("auto.yap");
  16.                 try{
  17.                         ObjectSet<AutoInfo> result = db.query(new Predicate<AutoInfo>() {
  18.                             public boolean match(AutoInfo ai) {
  19.                                 //匹配姓名和车牌号
  20.                                 return ai.getLicensePlate().equals("川B00000")
  21.                                            &amp;&amp; ai.getOwnerNo().getName().equals("张三");
  22.                             }
  23.                         });
  24.                         AutoInfo ai = result.next();
  25.                         //删除车辆信息
  26.                         db.delete(ai);
  27.                 }finally{
  28.                         //关闭连接
  29.                         db.close();
  30.                 }
  31.         }
  32. }

 

如图 4 所示，所关联的车辆信息已被删除了。
图4. 删除车辆信息
图4. 删除车辆信息

场景四

在场景三的基础上修改一下，设想“张三”由于工作不顺，导致最后维护汽车的开支都困难，他不得不退出有车一族的行列清单5：
清单5. 删除所有信息

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.         //级联设置
  15.                 Db4o.configure().objectClass("bo.People")
  16.         .cascadeOnDelete(true);
  17.                 //打开数据库
  18.                 ObjectContainer db = Db4o.openFile("auto.yap");
  19.                 try{
  20.                         ObjectSet<People> result = db.query(new Predicate<People>() {
  21.                             public boolean match(People people) {
  22.                                 //匹配姓名
  23.                                 return people.getName().equals("张三");
  24.                             }
  25.                         });
  26.                         People people = result.next();
  27.                         //删除车主以及关联的车辆信息
  28.                         db.delete(people);
  29.                 }finally{
  30.                         //关闭连接
  31.                         db.close();
  32.                 }
  33.         }
  34. }

 

用过 Hibernate 的开发者都知道，它的级联删除让人留下了深刻印象，第一次使用的时候都会为之振奋。db4o 也为开发者提供了级联删除，和场景二的级联更新一样， cascadeOnDelete() 是专门为删除准备的，基本概念和 cascadeOnUpdate() 一致。打开 ObjectManager 我们会发现数据库已经清空了，张三的购车经历到此结束。

结论

通过本系列文章，db4o 的优势已经体现得淋漓尽致，它的添加、更新、删除是如此的简单，正如 db4o 的口号那样——“仅需一行代码就能存储复杂结构对象，极大的降低了开发时间和成本，提供高效的性能，无需 DBA 干预”。

如本文有不详尽之处，大家可以参考官方的《用户指南》或访问 db4o 官方中文论坛，db4o 中文社区正在火热成长！

参考资料

学习

获得产品和技术

讨论

作者简介

  Rosen Jiang 来自成都，是 db4o 和 OO 的忠实 fans，是 2005 年 db4o 的 dvp 获得者之一。他正在 J2me 应用中使用 db4o，你可以通过 rosener_722@hotmail.com 和他联系。

 

  Chris 来自香港，热爱开源和 db4o。他创办了中国最火热的 Java 和开源社区 Matrix（http://www.Matrix.org.cn）， 你可以通过 chris@Matrix.org.cn 和他联系。

 

  张黄瞩，热爱开源软件，熟悉 Java/C/C++ 编程语言，对数据库技术网络技术均感兴趣。你可以通过 zhanghuangzhu@gmail.com 联系他。
]]> http://www.javagg.com/archives/774/feed 0 开源面向对象数据库 db4o 之旅: db4o 查询方式 http://www.javagg.com/archives/770 http://www.javagg.com/archives/770#comments Fri, 14 May 2010 02:12:06 +0000 纯净水 http://www.javagg.com/?p=770  

在 db4o 之旅 系列文章的第一部分：初识 db4o 中，作者介绍了 db4o 的历史和现状，应用领域，以及和 ORM 等的比较。在这篇文章中，作者将会介绍 db4o 的安装、启动以及三种不同的查询方式：QBE（Query by Example）、SODA（Simple Object Database Access） 以及 NQ（Native Queries），并分别通过这三种不同的途径实现了两个关联对象的查询。本文还示范了开发中最经常用到的几个典型功能的 db4o 实现。

db4o 所有最新的版本都可以直接在官方网站上下载，进入 db4o 的下载页面，我们可以看到最新的 for Java 稳定版本是 5.5，包括 JAR、源代码、入门文档、API 等内容的完整的打包文件只有 6 MB，db4o 还有一个对象数据库管理工具 ObjectManager，目前版本是 1.8（请在参考资源中下载）。

接着在 Eclipse 中新建 Java 项目，把 db4o 对象数据库引擎包 db4o-5.5-java5.jar 导入进项目。由于 db4o 支持多种版本的 JDK，除了 for JDK 5.0 的 db4o-5.5-java5.jar 外，还有 for JDK 1.1、1.2-1.4 的 JAR 包，以适应多种环境。与 Hibernate、iBATIS SQL Maps 相比，db4o 更加自然，无需过多地引用第三方支持库。

db4o 怎样进行对象持久化呢？通过浏览目录可以发现，与传统的 RDBMS 一样，db4o 也有自己的数据库文件, 在 db4o 中数据库文件的后缀名是“*.yap”。让我们先来了解一下 db4o 对象数据库引擎的主要包结构：

  • com.db4o
    com.db4o 包含了使用 db4o 时最经常用到的功能。两个最重要的接口是 com.db4o.Db4o 和 com.db4o.ObjectContainer。com.db4o.Db4o 工厂是运行 db4o 的起点，这个类中的静态方法可以开启数据库文件、启动服务器或连接一个已经存在的服务器，还可以在开启数据库之前进行 db4o 环境配置。com.db4o.ObjectContainer 接口很重要，开发过程中 99% 的时间都会用到它，ObjectContainer 可在单用户模式下作为数据库实例，也可作为 db4o 服务器的客户端。每个 ObjectContainer 实例都有自己的事务。所有的操作都有事务保证。当打开 ObjectContainer，就已经进入事务了，commit() 或 rollback() 时，下一个事务立即启动。每个 ObjectContainer 实例维护它自己所管理的已存储和已实例化对象，在需要 ObjectContainer 的时候，它会一直保持开启状态，一旦关闭，内存中数据库所引用的对象将被丢弃。
  • com.db4o.ext
    你也许想知道为什么在 ObjectContainer 中只能看见很少的方法，原因如下：db4o 接口提供了两个途径，分别在 com.db4o 和 com.db4o.ext 包中。这样做首先是为了让开发者能快速上手；其次为了让其他产品能更容易的复制基本的 db4o 接口；开发者从这一点上也能看出 db4o 是相当轻量级的。每个 com.db4o.ObjectContainer 对象也是 com.db4o.ext.ExtObjectContainer 对象。可以转换成 ExtObjectContainer 获得更多高级特性。
  • com.db4o.config
    com.db4o.config 包含了所有配置 db4o 所需的类。
  • com.db4o.query
    com.db4o.query 包包含了构造“原生查询, NQ（Native Queries）”所需的 Predicate 类。NQ 是 db4o 最主要的查询接口。

db4o 提供两种运行模式，分别是本地模式和服务器模式。本地模式是指直接在程序里打开 db4o 数据库文件进行操作：

ObjectContainer db = Db4o.openFile("auto.yap");

而服务器模式则是客户端通过 IP 地址、端口以及授权口令来访问服务器：

服务器端：

  1. ObjectServer server=Db4o.openServer("auto.yap",1212);
  2. server.grantAccess("admin","123456");

客户端：

  1. ObjectContainer db=Db4o.openClient("192.168.0.10",1212,"admin","123456");

 

两种方式都可以得到 ObjectContainer 实例，就目前 Java EE 应用环境来看，服务器模式更有现实意义；而本地模式更适合于嵌入式应用。为了简化演示，本文在下面的例子都将采用本地模式。

在下面的例子里，我们都会用到下面两个对象： People 和 AutoInfo 对象。

People 对象清单1：
清单1. People 对象

  1. package bo;
  2.  
  3. public class People {
  4.  
  5.         private java.lang.Integer _id;
  6.         private java.lang.String _name;
  7.         private java.lang.String _address;
  8.         private java.util.List<AutoInfo> _autoInfoList;
  9.  
  10.         public java.lang.Integer getId() {
  11.                 return _id;
  12.         }
  13.  
  14.         public void setId(java.lang.Integer _id) {
  15.                 this._id = _id;
  16.         }
  17.  
  18.         public java.lang.String getName() {
  19.                 return _name;
  20.         }
  21.  
  22.         public void setName(java.lang.String _name) {
  23.                 this._name = _name;
  24.         }
  25.  
  26.         public java.lang.String getAddress() {
  27.                 return _address;
  28.         }
  29.  
  30.         public void setAddress(java.lang.String _address) {
  31.                 this._address = _address;
  32.         }
  33.  
  34.         public java.util.List<AutoInfo> getAutoInfoList() {
  35.                 return this._autoInfoList;
  36.         }
  37.  
  38.         public void addAutoInfo(AutoInfo _autoInfoList) {
  39.                 if (null == this._autoInfoList)
  40.                         this._autoInfoList = new java.util.ArrayList<AutoInfo>();
  41.                 this._autoInfoList.add(_autoInfoList);
  42.         }
  43.  
  44. }

 

AutoInfo 对象清单2：
清单2. AutoInfo 对象

  1. package bo;
  2.  
  3. public class AutoInfo{
  4.  
  5.         private java.lang.Integer _id;
  6.         private java.lang.String _licensePlate;
  7.         private bo.People _ownerNo;
  8.  
  9.         public java.lang.Integer getId () {
  10.                 return _id;
  11.         }
  12.  
  13.         public void setId (java.lang.Integer _id) {
  14.                 this._id = _id;
  15.         }
  16.  
  17.         public java.lang.String getLicensePlate () {
  18.                 return _licensePlate;
  19.         }
  20.  
  21.         public void setLicensePlate (java.lang.String _licensePlate) {
  22.                 this._licensePlate = _licensePlate;
  23.         }
  24.  
  25.         public bo.People getOwnerNo () {
  26.                 return this._ownerNo;
  27.         }
  28.  
  29.         public void setOwnerNo (bo.People _ownerNo) {
  30.                 this._ownerNo = _ownerNo;
  31.         }
  32.  
  33. }

利用 set 方法把新对象存入 ObjectContainer，而对 ObjectContainer 中已有对象进行 set 操作则是更新该对象。db4o 保存数据库很简单，下面就是一个段完整的保存对象的代码：

AutoInfo 对象清单3：
清单3

  1. package com;
  2.  
  3. import bo.AutoInfo;
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8.  
  9. public class DB4OTest{
  10.  
  11.         public static void main(String[] args){
  12.                 //打开数据库
  13.                 ObjectContainer db = Db4o.openFile("auto.yap");
  14.                 try{
  15.                         //构造 People 对象
  16.                         People peo = new People();
  17.                         peo.setId(1);
  18.                         peo.setAddress("成都市");
  19.                         peo.setName("张三");
  20.                         //构造 AutoInfo 对象
  21.                         AutoInfo ai = new AutoInfo();
  22.                         ai.setId(1);
  23.                         ai.setLicensePlate("川A00000");
  24.                         //设置 People 和 AutoInfo 的关系
  25.                         ai.setOwnerNo(peo);
  26.                         peo.addAutoInfo(ai);
  27.                         //保存对象
  28.                         db.set(peo);
  29.                 }finally{
  30.                         //关闭连接
  31.                         db.close();
  32.                 }
  33.         }
  34. }

当我们运行上述代码，db4o 会自动创建“auto.yap”文件。让我们来看看到底保存成功没有，打开 ObjectManager 工具，如图 1 所示。
图1. 对象数据库管理工具
图1. 对象数据库管理工具

“File”－>“Open File”－>选择刚才我们保存的“auto.yap”文件（“auto.yap”文件可在项目的根目录下找到），最新的 ObjectManager 1.8 版本为我们提供了“Read Only”方式读取数据库文件，避免 ObjectManager 占用数据库文件所导致的程序异常。

打开之后，如图 2 所示，刚才存贮的 People 对象已经在数据库中了，并且还可以很直观的看到 AutoInfo 对象也放入了 ArrayList 中。这种可视化的对象关系有利于我们对数据的理解，是传统 RDBMS 无法比拟的。有些开发者会说 ObjectManager 工具略显简单，这点我想随着 db4o 的不断发展会加入更多的特性。在这个工具中，我们意外的发现了 Java 集合对象的踪影，db4o 把与 ArrayList 有直接关系的所有接口和父类都保存了，这样显得更直观。

在此，我保留了 _id 属性，这是因为通常在 Java EE 环境中，DAO 第一次不是把整个对象都返回到表现层，而是只返回了“标题”、“发布时间”这些信息（并隐式的返回id），接着 DAO 与数据库断开；要查看详情（比如文章内容）就需要进行 findById 操作，这时 DAO 要再次与数据库交互，只有唯一标识符才能正确地找到对象。这种懒加载方式也是很多书籍所推荐的。

回到本文的范例程序中，这个 _id 属性可由人工编码实现的“序列”进行赋值，当然 db4o 也提供了内部标识符 Internal IDs，如图 2 中的 id=1669；以及 UUIDs。
图2. 对象结构
图2. 对象结构

img src=”http://www.ibm.com/i/v14/rules/blue_rule.gif” alt=”" width=”100%” height=”1″ />

查询数据库

和 RDBMS 一样，db4o 也有自己的查询语言，分别是 QBE（Query by Example）、NQ（Native Queries）、SODA（Simple Object Database Access），db4o 更推荐使用 NQ 进行查询。NQ 方式提供了非常强大的查询功能，支持原生语言，也就意味着你可以使用 Java 来判断该对象是否符合条件，这是其他数据库查询语言无法比拟的。在某些情况下， db4o 核心会将 NQ 翻译成 SODA 以获得更高的性能。下面详细介绍一下这三种查询语言。

QBE（Query by Example）

QBE 规范可在这里下载。QBE 最初由 IBM 提出，同时业界也有许多和 QBE 兼容的接口，包括著名的 Paradox。有些系统，比如微软的 Access，它的基于表单的查询也是受到了部分 QBE 思想的启发。在 db4o 中，用户可借用 QBE 快速上手，可以很容易适应 db4o 存取数据的方式。

当利用 QBE 为 db4o 提供模板（example）对象时，db4o 将返回所有和非默认值字段匹配的全部对象。内部是通过反射所有的字段和构造查询表达式（所有非默认值字段结合”AND”表达式）来实现。

例如，利用 QBE 查找到车牌号为“川A00000”的车主姓名，这是一个级联查询。清单4：
清单4

  1. package com;
  2.  
  3. import java.util.List;
  4.  
  5. import bo.AutoInfo;
  6.  
  7. import com.db4o.Db4o;
  8. import com.db4o.ObjectContainer;
  9.  
  10. public class DB4OTest{
  11.  
  12.         public static void main(String[] args){
  13.                 //打开数据库
  14.                 ObjectContainer db = Db4o.openFile("auto.yap");
  15.                 try{
  16.                         //构造模板对象
  17.                         AutoInfo ai = new AutoInfo();
  18.                         ai.setLicensePlate("川A00000");
  19.                         //查询对象
  20.                         List<AutoInfo> list = db.get(ai);
  21.                 for(int x = 0; x < list.size(); x++){
  22.                         System.out.println("车主姓名："+list.get(x).getOwnerNo().getName());
  23.                         }
  24.                 }finally{
  25.                         //关闭连接
  26.                         db.close();
  27.                 }
  28.         }
  29. }

 

但是 QBE 也有明显的限制：db4o 必须反射模板（example）对象的所有成员；无法执行更进一步的查询表达式（例如 AND、OR、NOT 等等）；不能约束 0（整型）、””（空字符串）或者 null（对象），因为这些都被认为是不受约束的。要绕过这些限制，db4o 提供了 NQ（Native Queries）。

SODA（Simple Object Database Access）

SODA ，简单对象数据库访问，请查看官方站点，其中一位主要维护者是 Carl Rosenberger，Carl 正是 db4o 首席架构师。

SODA 就是一种与数据库通讯的对象 API。最终的目标是实现类型安全、对象复用、最小的字符串使用、与编程语言无关等特性。SODA 是 db4o 最底层的查询 API，目前 SODA 中使用字符串来定义字段，这样将不能实现类型安全也无法在编译时检查代码，而且写起来较麻烦，当然要达到设计目标这个阶段是必须的。大部分情况下 NQ（Native Queries）是很好的查询接口，不过遇到动态生成查询的时候 SODA 就大有作为了。

通过 SODA 查找到车牌号为“川A00000”的车主姓名。清单5：

  1. package com;
  2.  
  3. import java.util.List;
  4.  
  5. import bo.AutoInfo;
  6.  
  7. import com.db4o.Db4o;
  8. import com.db4o.ObjectContainer;
  9. import com.db4o.query.Query;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o.openFile("auto.yap");
  16.                 try{
  17.                         //构造查询对象
  18.                         Query query=db.query();
  19.                         //设置被约束实例
  20.                         query.constrain(AutoInfo.class);
  21.                         //设置被约束实例的字段和约束条件
  22.                         query.descend("_licensePlate").constrain("川A00000");
  23.                         //查询对象
  24.                         List<AutoInfo> list = query.execute();
  25.                 for(int x = 0; x < list.size(); x++){
  26.                         System.out.println("车主姓名："+list.get(x).getOwnerNo().getName());
  27.                         }
  28.                 }finally{
  29.                         //关闭连接
  30.                         db.close();
  31.                 }
  32.         }
  33. }

 

通过 API，发现 Query 实例增加了 sortBy 按字段排序方法和 orderAscending正序、orderDescending 倒序排列方法，SODA 比 QBE 更进了一步。
NQ（Native Queries）

精彩总是在最后出场，NQ 才是 db4o 查询方式中最精彩的地方！有没有想过用你熟悉的的编程语言进行数据库查询呢？要是这样，你的查询代码将是 100% 的类型安全、100% 的编译时检查以及 100% 的可重构，很奇妙吧？NQ 可以做到这些。

有两篇论文专门讲解了 NQ 的基本概念和设计思路，分别是 《Cook/Rosenberger，持久对象原生数据库查询语言》 和 《Cook/Rai，Safe Query Objects: Statically Typed Objects as Remotely Executable Queries》。作为结果集的一部分，NQ 表达式必须返回 true 值来标记特定实例。如果可能的话 db4o 将尝试优化 NQ 表达式，并依赖索引来运行表达式。

通过 NQ 查找到车牌号为“川A00000”的车主姓名。清单6：
清单6

  1. package com;
  2.  
  3. import java.util.List;
  4.  
  5. import bo.AutoInfo;
  6.  
  7. import com.db4o.Db4o;
  8. import com.db4o.ObjectContainer;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o.openFile("auto.yap");
  16.                 try{
  17.                         List <AutoInfo> list = db.query(new Predicate<AutoInfo>() {
  18.                                 public boolean match(AutoInfo ai) {
  19.                                 //这样才是类型安全的
  20.                                 return ai.getLicensePlate().equals("川A00000");
  21.                             }
  22.                         });
  23.                 for(int x = 0; x < list.size(); x++){
  24.                         System.out.println(list.get(x).getOwnerNo().getName());
  25.                         }
  26.                 }finally{
  27.                         //关闭连接
  28.                         db.close();
  29.                 }
  30.         }
  31. }

 

必须指出 NQ 的一个的问题是：在内部，db4o 设法把 NQ 转换成 SODA。但并不是所有的查询表达式都可以成功转换。有些查询表达式的流向图（flowgraph）非常难于分析。这种情况下，db4o 将不得不实例化一些持久对象来真实地运行 NQ 表达式。

正在开发中的 NQ 查询优化器就可以化解这个障碍，它将分析 NQ 表达式的每个部分，以确保最少量的实例化对象，以此提高性能。当然，优化器的不是灵丹妙药，关键还需要自己多优化代码。

开发 Java EE 项目经常会用到分页，怎样用 NQ 实现呢？向数据库写入六条记录。清单7：
清单7

  1. package com;
  2.  
  3. import java.util.List;
  4.  
  5. import bo.AutoInfo;
  6.  
  7. import com.db4o.Db4o;
  8. import com.db4o.ObjectContainer;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest{
  12.  
  13.         public static void main(String[] args){
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o.openFile("auto.yap");
  16.                 try{
  17.                         List<AutoInfo> list = db.query(new Predicate<AutoInfo>() {
  18.                                 public boolean match(AutoInfo ai) {
  19.                                 return true;
  20.                             }
  21.                         });
  22.                         //记录总数
  23.                         Integer count = list.size();
  24.                         //每页两条，分三页
  25.                 for(int x = 0; x < 3; x++){
  26.                         System.out.println("第"+x+"页："+list.get(x*2).getLicensePlate());
  27.                         System.out.println("第"+x+"页："+list.get(x*2+1).getLicensePlate());
  28.                         }
  29.                 }finally{
  30.                         //关闭连接
  31.                         db.close();
  32.                 }
  33.         }
  34. }

 

我们发现，在进行 NQ 查询时并没有加入任何条件（无条件返回 true），是不是相当于遍历了整个数据库？db4o 的设计者早就想到了这个问题，当 db.query() 执行完毕返回 list 实例的时候，db4o 只是与数据库同步取出内部 IDs 而已，并没有把所有的 AutoInfo 对象全部取出，只有在 list.get(x*2).getLicensePlate() 之后才会去根据 IDs 取出记录。所以不必担心性能问题。
  

 结论

db4o 为开发者提供了多种查询方式，这些方式都很灵活。要引起大家注意的是：灵活在带来便利的同时也对开发者自身素质提出了更高的要求，（比如排序，既可以用 SODA 也可以用 Java 集合对象实现）在开发过程中一定要形成某种统一的开发模式，这样 db4o 才能最高效能地为我所用。

参考资料

学习

获得产品和技术

]]> http://www.javagg.com/archives/770/feed 0 mysql使用普通用户备份出现的错误 http://www.javagg.com/archives/726 http://www.javagg.com/archives/726#comments Thu, 08 Apr 2010 08:03:00 +0000 纯净水 http://www.javagg.com/?p=726 mysql使用普通用户备份出现：

[root@xok.la]# mysqldump -u dbuser -ppass db > db.sql
mysqldump: Got error: 1044: Access denied for user ‘dbuser’@'localhost’ to database ‘db’ when using LOCK TABLES
解决一：

加上-skip-lock-tables选项即可。即：

[root@xok.la]# mysqldump -u dbuser -ppass db –skip-lock-tables > db.sql
解决2：

使用root账户备份。

]]> http://www.javagg.com/archives/726/feed 0 mysql中text,longtext,mediumtext字段类型的意思,以及区别 http://www.javagg.com/archives/721 http://www.javagg.com/archives/721#comments Thu, 08 Apr 2010 04:04:51 +0000 纯净水 http://www.javagg.com/?p=721 MySQL支持大量的列类型，它可以被分为3类：数字类型、日期和时间类型以及字符串(字符)类型。本节首先给出可用类型的一个概述，并且总结每个列类型的存储需求，然后提供每个类中的类型性质的更详细的描述。概述有意简化，更详细的说明应该考虑到有关特定列类型的附加信息，例如你能为其指定值的允许格式。

由MySQL支持的列类型列在下面。下列代码字母用于描述中：

M
指出最大的显示尺寸。最大的合法的显示尺寸是 255 。
D
适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的值是30，但是应该不大于M-2。
方括号(“[”和“]”)指出可选的类型修饰符的部分。

注意，如果你指定一个了为ZEROFILL，MySQL将为该列自动地增加UNSIGNED属性。

TINYINT[(M)] [UNSIGNED] [ZEROFILL]
一个很小的整数。有符号的范围是-128到127，无符号的范围是0到255。

SMALLINT[(M)] [UNSIGNED] [ZEROFILL]
一个小整数。有符号的范围是-32768到32767，无符号的范围是0到65535。

MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL]
一个中等大小整数。有符号的范围是-8388608到8388607，无符号的范围是0到16777215。

INT[(M)] [UNSIGNED] [ZEROFILL]
一个正常大小整数。有符号的范围是-2147483648到2147483647，无符号的范围是0到4294967295。

INTEGER[(M)] [UNSIGNED] [ZEROFILL]
这是INT的一个同义词。

BIGINT[(M)] [UNSIGNED] [ZEROFILL]

一个大整数。有符号的范围是-9223372036854775808到9223372036854775807，无符号的范围是0到

18446744073709551615。注意，所有算术运算用有符号的BIGINT或DOUBLE值完成，因此你不应该使用大于9223372036854775807（63位)的有符号大整数，除了位函数！注意，当两个参数是INTEGER值时，-、+和*将使用BIGINT运算！这意味着如果你乘2个大整数(或来自于返回整数的函数)，如果结果大于9223372036854775807，你可以得到意外的结果。一个浮点数字，不能是无符号的，对一个单精度浮点数，其精度可以是<=24，对一个双精度浮点数，是在25 和53之间，这些类型如FLOAT和DOUBLE类型马上在下面描述。FLOAT(X)有对应的FLOAT和DOUBLE相同的范围，但是显示尺寸和小数位数是未定义的。在MySQL3.23中，这是一个真正的浮点值。在更早的MySQL版本中，FLOAT(precision)总是有2位小数。该句法为了ODBC兼容性而提供。

FLOAT[(M,D)] [ZEROFILL]
一个小(单精密)浮点数字。不能无符号。允许的值是-3.402823466E+38到-1.175494351E-38，0 和1.175494351E-38到3.402823466E+38。M是显示宽度而D是小数的位数。没有参数的FLOAT或有<24 的一个参数表示一个单精密浮点数字。

DOUBLE[(M,D)] [ZEROFILL]
一个正常大小(双精密)浮点数字。不能无符号。允许的值是-1.7976931348623157E+308到-2.2250738585072014E-308、 0和2.2250738585072014E-308到1.7976931348623157E+308。M是显示宽度而D是小数位数。没有一个参数的DOUBLE或FLOAT(X)（25 < = X < = 53）代表一个双精密浮点数字。

DOUBLE PRECISION[(M,D)] [ZEROFILL]

REAL[(M,D)] [ZEROFILL]
这些是DOUBLE同义词。

DECIMAL[(M[,D])] [ZEROFILL]
一个未压缩(unpack)的浮点数字。不能无符号。行为如同一个CHAR列：“未压缩”意味着数字作为一个字符串被存储，值的每一位使用一个字符。小数点，并且对于负数，“-”符号不在M中计算。如果D是0，值将没有小数点或小数部分。DECIMAL值的最大范围与DOUBLE相同，但是对一个给定的DECIMAL列，实际的范围可以通过M和D的选择被限制。如果D被省略，它被设置为0。如果M被省掉，它被设置为10。注意，在MySQL3.22里，M参数包括符号和小数点。

NUMERIC(M,D) [ZEROFILL]
这是DECIMAL的一个同义词。

DATE
一个日期。支持的范围是’1000-01-01′到’9999-12-31′。MySQL以’YYYY-MM-DD’格式来显示DATE值，但是允许你使用字符串或数字把值赋给DATE列。

DATETIME
一个日期和时间组合。支持的范围是’1000-01-01 00:00:00′到’9999-12-31 23:59:59′。MySQL以’YYYY-MM-DD HH:MM:SS’格式来显示DATETIME值，但是允许你使用字符串或数字把值赋给DATETIME的列。

TIMESTAMP[(M)]
一个时间戳记。范围是’1970-01-01 00:00:00′到2037年的某时。MySQL以YYYYMMDDHHMMSS、YYMMDDHHMMSS、YYYYMMDD或YYMMDD格式来显示TIMESTAMP值，取决于是否M是14（或省略)、12、8或6，但是允许你使用字符串或数字把值赋给TIMESTAMP列。一个TIMESTAMP列对于记录一个INSERT或UPDATE操作的日期和时间是有用的，因为如果你不自己给它赋值，它自动地被设置为最近操作的日期和时间。你以可以通过赋给它一个NULL值设置它为当前的日期和时间。
TIME
一个时间。范围是’-838:59:59′到’838:59:59′。MySQL以’HH:MM:SS’格式来显示TIME值，但是允许你使用字符串或数字把值赋给TIME列。

YEAR[(2|4)]
一个2或4位数字格式的年(缺省是4位)。允许的值是1901到2155，和0000（4位年格式），如果你使用2位，1970-2069( 70-69)。MySQL以YYYY格式来显示YEAR值，但是允许你把使用字符串或数字值赋给YEAR列。（YEAR类型在MySQL3.22中是新类型。）

CHAR(M) [BINARY]
一个定长字符串，当存储时，总是是用空格填满右边到指定的长度。M的范围是1 ～ 255个字符。当值被检索时，空格尾部被删除。CHAR值根据缺省字符集以大小写不区分的方式排序和比较，除非给出BINARY关键词。NATIONAL CHAR（短形式NCHAR)是ANSI SQL的方式来定义CHAR列应该使用缺省字符集。这是MySQL的缺省。CHAR是CHARACTER的一个缩写。

[NATIONAL] VARCHAR(M) [BINARY]
一个变长字符串。注意：当值被存储时，尾部的空格被删除(这不同于ANSI SQL规范)。M的范围是1 ～ 255个字符。 VARCHAR值根据缺省字符集以大小写不区分的方式排序和比较，除非给出BINARY关键词值。 VARCHAR是CHARACTER VARYING一个缩写。

TINYBLOB

TINYTEXT
一个BLOB或TEXT列，最大长度为255(2^8-1)个字符。
BLOB

TEXT
一个BLOB或TEXT列，最大长度为65535(2^16-1)个字符。

MEDIUMBLOB

MEDIUMTEXT
一个BLOB或TEXT列，最大长度为16777215(2^24-1)个字符。
LONGBLOB

LONGTEXT
一个BLOB或TEXT列，最大长度为4294967295(2^32-1)个字符。

ENUM(‘value1′,’value2′,…)
枚举。一个仅有一个值的字符串对象，这个值式选自与值列表’value1′、’value2′, …,或NULL。一个ENUM最多能有65535不同的值。

SET(‘value1′,’value2′,…)
一个集合。能有零个或多个值的一个字符串对象，其中每一个必须从值列表’value1′, ‘value2′, …选出。一个SET最多能有64个成员。

]]> http://www.javagg.com/archives/721/feed 0 cassandra 学习笔记(5) http://www.javagg.com/archives/684 http://www.javagg.com/archives/684#comments Mon, 15 Mar 2010 01:55:50 +0000 纯净水 http://www.javagg.com/?p=684 1)columnFamily下一个column和多个column的读取区别
2)columnfamily 和superColumnFamily的读取区别

测试机数量：两台，jvm最大使用内存都开到1.3G。

起始key: 1356278962 ;

改变组：
product_name1    :    “是一个非常可靠的大规模分布式存储系统”
product_name2    :    “中国惨败伊朗丢亚锦赛冠军创34年参赛最耻辱一败”

控制组：
product_value1    :    “第一次在主场丢冠军”
product_value2    :    “胡雪峰顶替受伤的刘炜”
product_value3    :    “朱芳雨都有外线出手机会”
product_value4    :    “张庆鹏传球意图太过明显”
product_value5    :    “最后一节比赛”
product_value6    :    “中国队首发：易建联、王治郅、朱芳雨、王仕鹏、胡雪峰”
product_value7    :    “中国队本次亚锦赛首次尝到失利的滋味，在家门口把冠军拱手相让”
product_value8    :    “下半场易边再战，中国队仍然如同梦游，球员之间没有形成整体”

//下面这个是一个要存入的“摘要”
product_value9    :    “下半场易边再战，中国队仍然如同梦游，球员之间没有形成整体，
            单打独斗的进攻模式成功率相当低。伊朗队内外结合，多点得分，
            继续扩大分差。朱芳雨传球被断，对手长传快攻，14号球员扣篮得分，
            28-53。王治郅强攻得手，造成哈达迪犯规，加罚命中。
            王治郅再次溜到篮下，反身投篮得分。王治郅成为中国队的唯一亮点，
            持球接连晃过三名球员的防守，投篮得分，加罚再中，
            36-53。靠着王治郅的出色发挥，中国队留住翻盘的一线希望。
            第三节结束，39-56，分差仍为17分。”

   
我们有的ColumnFamily: Standard1 Standard2 Super1 Super2

测试1：    向Standard1中写入10万条记录，此时Standard1中只有”product_name”一个column,key是从1356278962开始往后10万个

    insert()进行插入，速度很慢，不可能在一小时内完成
    CQL 用时256秒,关掉log后用时55秒

测试2：    然后在product_name1 和 product_name2之间反复修改key-1356279962对应的”produck_name”这个column的内容10万次
    CQL：

    当config中的ReplicationFactor为1的时候，用时120秒
    当config中的ReplicationFactor为2的时候，用时183秒；关掉log后用时42秒

   
测试3：    将存在的各个key的product_name读取一遍（此时相应columnFamily中只有1个column）
    当config中的ReplicationFactor为1的时候：速度相当慢
    当config中的ReplicationFactor为2的时候：

        CQL：

        用时267秒；关掉log后用时145秒

        API：
        用get_column用时203秒；关掉log后用时135秒

以下均以ReplicationFactor=2来进行测试

测试4：    依照已经存在的各个key，向Standard1中写入10万条控制组里面的column数据
    API：

    batch_insert() 速度非常慢

    CQL：
    90万个column元素,其中包括一个类似摘要大小的字符串(200字左右)，用时2004秒；关掉log后用时512秒。

测试5：    然后在product_name1 和 product_name2之间反复修改key-1356279962对应的”produck_name”这个column的内容10万次

    API：
    使用insert()速度相当慢

    CQL：
    用时190秒；关掉log后用时45秒

测试6：    将存在的各个key的product_name读取一遍（此时相应columnFamily中已经有10个column了）

    API：

    使用get_column()用时757秒;关掉log后用时188秒

    CQL：

    用时更慢一些，用时861秒;关掉log后用时202秒

super测试1：在Super1中创建superColumn1，在superColumn1中只创建1个column-”product_name”,然后写入10万条数据,key是从1356278962开始往后10万个

    CQL：

    用时316秒;关掉log后用时60秒
super测试2：然后在product_name1 和 product_name2之间反复修改superColumn1下key-1356279962对应的”produck_name”这个column的内容10万次
    CQL：

    用时195秒;关掉log后用时62秒
super测试3：将存在的各个key的product_name读取一遍（此时相应superColumnFamily中只有1个column）

    API：

    get_column() 用时235秒;关掉log后用时234秒

    CQL：

    用时356秒 ;关掉log后用时158秒

super测试4：依照已经存在的各个key,依次向superColumn1中写入10万条控制组里面的column数据

    CQL：

    用时2058秒;关掉log后，竟然非常慢，不知道为什么，但是重新启动下节点后，速度变快，用时562秒
super测试4：然后在product_name1 和 product_name2之间反复修改superColumn1下key-1356279962对应的”produck_name”这个column的内容10万次

   CQL：

   用时190秒,关掉log后用时48秒
super测试6：将存在的各个key的product_name读取一遍（此时相应superColumnFamily中已经有10个column了）

    API：

    用get_column 用时 356秒;关掉log后用时191秒

    CQL：

    用时314秒;关掉log后用时208秒

结论：使用superColumn的开销不比column大很多，向columnFamily中加入更多的column对读取速度的影响不大。相比而言受log和ReplicationFactor的影响更大。另外在写入的时候CQL的效率更高，在读取的时候get_column更好一些。而API中的其他方法如batch_insert()，insert()效率明显不高。但这只是两个节点的情况，当有更多节点的时候情况可能又会不一样了。

转：http://blog.csdn.net/pakly_9527/archive/2009/08/17/4456357.aspx

]]> http://www.javagg.com/archives/684/feed 0 cassandra 学习笔记(4) http://www.javagg.com/archives/682 http://www.javagg.com/archives/682#comments Mon, 15 Mar 2010 01:55:10 +0000 纯净水 http://www.javagg.com/?p=682 (一)依赖:cassandra.jar

             libthrift.jar

(二)连接:

    //该方法将返回一个Cassandra.Client实例,该实例包含和server端指定节点会话的API

  1.  
  2.      public Cassandra.Client getClient()
  3.     {
  4.         //192.168.0.169为想连接到的某个节点的ip,9160为端口<span id="more-682"></span>
  5.  
  6.         TSocket socket = new TSocket("192.168.0.169", 9160);
  7.  
  8.         TTransport transport_ = socket;
  9.  
  10.         TBinaryProtocol binaryProtocol = new TBinaryProtocol(transport_, false, false);
  11.         Cassandra.Client cassandraClient = new Cassandra.Client(binaryProtocol);
  12.  
  13.         try
  14.         {
  15.             transport_.open();
  16.         }
  17.         catch(Exception e)
  18.         {
  19.             // Should move this to Log4J as well probably…
  20.             System.err.println("Exception " + e.getMessage());          
  21.             e.printStackTrace();
  22.         }
  23.       
  24.         return cassandraClient;
  25.      
  26.     }
  27.  

(三)API

1)该方法向key的指定path插入一个数据，另外想要对key某指定path的数据进行修改也使用这个方法

   代码中的cli是一个Cassandra.Client实例

  1.  
  2.      public void test_insert()
  3.     {
  4.         try {
  5.             String tableName = "Table1";
  6.             String key = "testkey";
  7.             String columnFamily = "Standard1";
  8.             String columnName = "testColumn";
  9.             String value = "testValue";
  10.  
  11.             //对数据进行定位
  12.             String path = columnFamily+":"+columnName;
  13.             //向cassandra中插入一条数据
  14.             cli.insert(tableName,key,path,value.getBytes(),System.currentTimeMillis(),true);
  15.         } catch (InvalidRequestException e) {
  16.             e.printStackTrace();
  17.         } catch (TException e) {
  18.             e.printStackTrace();
  19.         } catch (UnavailableException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23.  

2)该方法试用Cql语句的方式发送请求，有一个问题就是当请求的参数或不正确的时候，方法不会报错，只是返回为空；

   但是在语法出现错误的时候还是会有InvalidRequestException抛出,提示Unresolved compilation problems

   代码中的cli是一个Cassandra.Client实例

  1.  
  2.    public void test_excuteQuery()
  3.     {
  4.         try {
  5.             cli.executeQuery("set Table1.Standard1['testKey2']['testColumn']=’testValue2′");
  6.             CqlResult_t crt = cli.executeQuery("get Table1.Standard1['testKey2']");
  7.             List<Map<String, String>> rs = crt.getResultSet();
  8.             //遍历显示所有column_t中的内容
  9.             if(rs != null){
  10.                 for(int i = 0 ; i < rs.size() ; i++){
  11.                     Map<String , String> map = rs.get(i);
  12.                     for(String key : map.keySet()){
  13.                         System.out.println(key+" : "+map.get(key));
  14.                     }
  15.                 }
  16.             }else{
  17.                 System.out.println("result set is null");
  18.             }
  19.         } catch (TException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23.  

3)根据path信息获取一个column

   path是一个定位信息，standard column family是两层 super column family是三层

   superColumnFamily:superColumn:standardColumn。

  1.  
  2.    public void test_get_column()
  3.     {
  4.         String tableName = "Table1";
  5.         String key = "testKey2";
  6.         String columnFamily = "Standard1";
  7.         String column = "testColumn";
  8.         String path = columnFamily+":"+column;
  9.         try {
  10.             column_t cmt = cli.get_column(tableName, key, path);
  11.             //以下两个是等价的
  12.             System.out.println(cmt.getColumnName());
  13.             System.out.println(cmt.getFieldValue(1));
  14.             //以下两个是等价的
  15.             System.out.println(new String(cmt.getValue(),"UTF-8"));
  16.             System.out.println(new String((byte[]) cmt.getFieldValue(2),"UTF-8"));
  17.             //以下两个是等价的
  18.             System.out.println(cmt.getTimestamp());
  19.             System.out.println(cmt.getFieldValue(3));
  20.           
  21.         } catch (InvalidRequestException e) {
  22.             e.printStackTrace();
  23.         } catch (NotFoundException e) {
  24.             e.printStackTrace();
  25.         } catch (TException e) {
  26.             e.printStackTrace();
  27.         } catch (UnsupportedEncodingException e) {
  28.             e.printStackTrace();
  29.         }
  30.     }

4)

    //术语解释：每个key都对应一个Row的信息这个Row的信息又按照columnFamliy 分成了很多slice

    //给定table,key和columnFamily的信息，
    //此方法将返回，该key在当前columnFamily的slice中有都少个column元素
    //该例子中key:”testKey2″在columnFamily:”Standard1″中的slice有几个column元素

  1.  
  2.     public void test_get_column_count()
  3.     {
  4.         String tableName = "Table1";
  5.         String keyName = "testKey2";
  6.         String columnFamily = "Standard1";
  7.         try {
  8.             System.out.println(cli.get_column_count(tableName, keyName, columnFamily));
  9.         } catch (InvalidRequestException e) {
  10.             e.printStackTrace();
  11.         } catch (TException e) {
  12.             e.printStackTrace();
  13.         }
  14.     }
  15.  

5) //暂不确定

    //根据给定的时间点，取出以后的对应给定key的一组columns
    //但是好像在时间上有延迟,这个不确定

  1.  
  2.     public void test_get_columns_since()
  3.     {
  4.         String tableName = "Table1";
  5.         String keyName = "testKey2";
  6.         String columnFamily = "Standard1";
  7.         Long sinceTime = System.currentTimeMillis()-5000*1000;//取当前时间之前120秒以内的
  8.         try {
  9.             List<column_t> cmts = cli.get_columns_since(tableName , keyName , columnFamily , sinceTime);
  10.             System.out.println("cmts size : "+cmts.size());
  11.         } catch (InvalidRequestException e) {
  12.             e.printStackTrace();
  13.         } catch (NotFoundException e) {
  14.             e.printStackTrace();
  15.         } catch (TException e) {
  16.             e.printStackTrace();
  17.         } catch (UnsupportedEncodingException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21.  

6)//range queries may only be performed against an order-preserving partitioner
    //如果系统试用的节点定位的RandomPartitioner的话那么这个方法将不能试用，好处是跟均衡的存储

  1.  
  2.     //此方法尚在研究中
  3.     public void test_get_key_range()
  4.     {
  5.         try {
  6.             cli.get_key_range("Table1", "？？", "？？", 1);
  7.           
  8.         } catch (InvalidRequestException e) {
  9.             e.printStackTrace();
  10.         } catch (TException e) {
  11.             e.printStackTrace();
  12.         }
  13.     }
  14.  

7) //术语解释：每个key都对应一个Row的信息这个Row的信息又按照columnFamliy 分成了很多slice

  1.  
  2.     //每一个columnFamily都存在一个排序,或按照name或按照time
  3.     //该方法将取出对应某个key的一定区间段内的column元素
  4.     public void test_get_slice()
  5.     {
  6.         String tableName = "Table1";
  7.         String keyName = "testKey2";
  8.         String columnFamily = "Standard1";    //想要从哪个columnFamily中获取column
  9.         int start = 0;//起始位置
  10.         int count = 10;//获取数量
  11.         try {
  12.             List<column_t> cmts = cli.get_slice(tableName, keyName, columnFamily, start, count);
  13.             System.out.println("cmts size : "+cmts.size());
  14.         } catch (InvalidRequestException e) {
  15.             e.printStackTrace();
  16.         } catch (NotFoundException e) {
  17.             e.printStackTrace();
  18.         } catch (TException e) {
  19.             e.printStackTrace();
  20.         } catch (UnsupportedEncodingException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }

8) //通过一个column的名字数组来查找相对应的属于给定key的slice（一组column 元素）

  1.  
  2.     public void test_get_slice_by_names()
  3.     {
  4.         String tableName = "Table1";
  5.         String keyName = "testKey";
  6.         String columnFamily = "Standard1";
  7.         List<String> columnNameList = new ArrayList<String>();
  8.         columnNameList.add("testColumn");
  9.         try{
  10.             List<column_t> cmts = cli.get_slice_by_names(tableName, keyName, columnFamily, columnNameList);
  11.         }catch(Exception e){
  12.             e.printStackTrace();
  13.         }
  14.     }
  15.  

9)//描述一个table中的各个columnFamily的基本信息

  1.  
  2.     public void test_describe_table()
  3.     {
  4.         try {
  5.             System.out.println(cli.describeTable("Table1"));
  6.         } catch (TException e) {
  7.             e.printStackTrace();
  8.         }
  9.     }
  10.  

10)//批量的针对一个key插入数据

  1.  
  2.     public void test_batch_insert()
  3.     {
  4.         try{
  5.             String tableName = "Table1";
  6.             String keyName = "testkey2";
  7.             //当下的Map保存了ColumnFamily到他内部的column元素列表的一个映射
  8.             //所以String 应该保存 对应columnFamily的名字。
  9.             //column_t(column元素)包含：columnName , value , timestamp 三要素
  10.             Map<String , List<column_t>> CFmap = new HashMap<String , List<column_t>>();
  11.             //制作两个column_t实例
  12.             column_t cmt1 = new column_t("test_column_name_1" , "test_column_value_1".getBytes() , System.currentTimeMillis());
  13.             column_t cmt2 = new column_t("test_column_name_2" , "test_column_value_2".getBytes() , System.currentTimeMillis());
  14.             //制作一个column_t的list
  15.             List<column_t> cList = new ArrayList<column_t>();
  16.             cList.add(cmt1);
  17.             cList.add(cmt2);
  18.             //制作一个将其写入CFmap中
  19.             String columnFamilyName = "Standard1";
  20.             CFmap.put(columnFamilyName, cList);//这样在以后的插入操作中，相应的column_t将插入"Docin"这个family中
  21.             batch_mutation_t bmt = new batch_mutation_t(tableName , keyName , CFmap);//完成插入的key的定位
  22.             //执行这个针对相应key和colmunFamily的batch_insert
  23.             cli.batch_insert(bmt, true);
  24.            
  25.         }catch(Exception e){
  26.             e.printStackTrace();
  27.         }
  28.     }
  29.  

11)//同insert()相对的反向操作
    //当我们试图查询一个不存在的column_t元素的时候，会有”NotFoundException”异常被抛出

  1.  
  2.     public void test_remove()
  3.     {
  4.         String tableName = "Table1";
  5.         String columnFamily = "Standard1";
  6.         String columnName = "removetest";
  7.         String keyName = "removetestkey";
  8.         String value = "removetestvalue";
  9.         String path = columnFamily+":"+columnName;
  10.         try{
  11.             //先将相应的column元素写入
  12.             cli.insert(tableName, keyName, path, value.getBytes(), System.currentTimeMillis(), true);
  13.             //尝试读出信息
  14.             column_t cmt = cli.get_column(tableName, keyName, path);
  15.             displayColumn(cmt);
  16.             //删除这条信息
  17.             cli.remove(tableName, keyName, path, System.currentTimeMillis(), true);
  18.         }catch(Exception e){
  19.             e.printStackTrace();
  20.         }
  21.         //尝试读出信息
  22.         column_t cmt2;
  23.         try {
  24.             cmt2 = cli.get_column(tableName, keyName, path);
  25.             displayColumn(cmt2);
  26.         } catch (InvalidRequestException e) {
  27.             e.printStackTrace();
  28.         } catch (NotFoundException e) {
  29.             System.out.println("NotFoundException 异常抛出，column_元素已经被删除");
  30.         } catch (TException e) {
  31.             e.printStackTrace();
  32.         } catch (UnsupportedEncodingException e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  36.  

12)//插入一个superColumn元素
    //不含有内容的superColumn不能同过该方法被创建,会抛出异常

  1.  
  2.     public void test_batch_insert_super_t()
  3.     {
  4.         try {
  5.             String tableName    = "Table1";
  6.             String keyName        = "superkeytest";
  7.             String superColumnFamilyName = "Super1";
  8.             //产生1个superColumn元素
  9.             //首先产生1个column_t的list
  10.             List<column_t> Clist = new ArrayList<column_t>();
  11.             //当两个名字一样的时候，先前的会被覆盖
  12.             Clist.add(new column_t("stardcolumninsuper1","stardcolumn1".getBytes(),System.currentTimeMillis()));
  13.             Clist.add(new column_t("stardcolumninsuper2","stardcolumn2".getBytes(),System.currentTimeMillis()));
  14.             //产生一个superColumn元素
  15.             String superColumnName = "superColumn3";
  16.             superColumn_t sct = new superColumn_t(superColumnName , Clist);
  17.             //将这个元素装入到一个superColumn_t的List中
  18.             List<superColumn_t> SClist = new ArrayList<superColumn_t>();
  19.             SClist.add(sct);
  20.             //将这个super_column 的list连同对应的superColumnFamily的名字一起放入一个hashmap中
  21.             Map<String , List<superColumn_t>> cfmap = new HashMap<String , List<superColumn_t>>();
  22.             cfmap.put(superColumnFamilyName, SClist);
  23.             //区别于一般的，这里要求的column元素是superColumn元素
  24.             //将整理好的信息关联一个key后生成一个mutation
  25.             batch_mutation_super_t bmst = new batch_mutation_super_t(tableName,keyName,cfmap);
  26.             boolean block = true;
  27.             //执行这个mutation的插入操作
  28.             cli.batch_insert_superColumn(bmst, block);
  29.         } catch (InvalidRequestException e) {
  30.             e.printStackTrace();
  31.         } catch (UnavailableException e) {
  32.             e.printStackTrace();
  33.         } catch (TException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37.  

13)//获取一个SuperColumn中的信息

  1.  
  2.     public void test_get_superColumn()
  3.     {
  4.         String tableName = "Table1";
  5.         String keyName = "superkeytest";
  6.         String superColumnFamilyName = "Super1";
  7.         String superColumnName = "superColumn3";
  8.         String path = superColumnFamilyName+":"+superColumnName;
  9.         try {
  10.             superColumn_t sct = cli.get_superColumn(tableName, keyName, path);
  11.             if(sct != null){
  12.                 System.out.println("Super Name : "+sct.getName());
  13.                 System.out.println("Size : "+sct.getColumnsSize());
  14.                 List<column_t> clist = sct.getColumns();
  15.             }else{
  16.                 System.out.println("super column is empty");
  17.             }
  18.         } catch (InvalidRequestException e) {
  19.             e.printStackTrace();
  20.         } catch (NotFoundException e) {
  21.             e.printStackTrace();
  22.         } catch (TException e) {
  23.             e.printStackTrace();
  24.         } catch (UnsupportedEncodingException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28.  

14)//尝试向一个superColumn中添加column元素(就是column_t对象)
   //注意：想superColumnFamily中添加一般的column元素是不被允许的,所以superColumnFamliy中只能有superColumn，而superColumn中只能有一般的column
   //而一般的columnFamily中也只能有一般的column

  1.  
  2.     public void test_insert_standard_to_super()
  3.     {
  4.         String tableName = "Table1";
  5.         String keyName = "superkeytest";
  6.         String superColumnFamily = "Super1";
  7.         String superColumnName = "superColumn1";
  8.         String columnName = "normal_column";
  9.         String value = "normal_column_value_add";
  10.         String path = superColumnFamily+":"+superColumnName+":"+columnName;
  11.         try {
  12.             cli.insert(tableName, keyName, path, value.getBytes(),System.currentTimeMillis(), true);
  13.             //尝试取出这个元素并显示这个元素
  14.             column_t cmt = cli.get_column(tableName, keyName, path);
  15.             if(cmt != null){
  16.                 System.out.println("column name : "+cmt.getColumnName());
  17.                 System.out.println("column value: "+new String(cmt.getValue(),"UTF-8"));
  18.                 System.out.println("column time : "+cmt.getTimestamp()+"\n");
  19.             }else{
  20.                 System.out.println("column is empty");
  21.             }
  22.         } catch (InvalidRequestException e) {
  23.             e.printStackTrace();
  24.         } catch (UnavailableException e) {
  25.             e.printStackTrace();
  26.         } catch (TException e) {
  27.             e.printStackTrace();
  28.         } catch (NotFoundException e) {
  29.             e.printStackTrace();
  30.         } catch (UnsupportedEncodingException e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34.  

15)//术语解释：每个key都对应一个Row的信息这个Row的信息又按照columnFamliy 或superColumnFamily分成了很多slice
    //同针对一般的columnFamliy类似,这个方法是获取给定key的某个superColumnFamily的slice，这个slice中的元素都是superColumn

  1.  
  2.     public void test_get_slice_super()
  3.     {
  4.         String tableName = "Table1";
  5.         String keyName = "superkeytest";
  6.         String superColumnFamily = "Super1";
  7.         try {
  8.             List<superColumn_t> sct = cli.get_slice_super(tableName, keyName, superColumnFamily, 0, 10);
  9.         } catch (InvalidRequestException e) {
  10.             e.printStackTrace();
  11.         } catch (TException e) {
  12.             e.printStackTrace();
  13.         } catch (UnsupportedEncodingException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  17.  

16)
//尝试删除一个superColumn节点，和属于该节点的column_t节点
    //测试需要通过path来定位这个节点

  1.  
  2.     public void test_remove_super()
  3.     {
  4.         String tableName = "Table1";
  5.         String keyName = "superkeytest";
  6.         String superColumnFamily = "Super1";
  7.         String superColumn = "superColumn3";
  8.         String columnName = "stardcolumninsuper1";
  9.         String path = superColumnFamily+":"+superColumn+":"+columnName;
  10.        
  11.         try {
  12.             //先建立一个super_column_family 名字测试的时候是"superColumn3"
  13.             //产生1个superColumn元素
  14.             //首先产生1个column_t的list
  15.             List<column_t> Clist = new ArrayList<column_t>();
  16.             //当两个名字一样的时候，先前的会被覆盖
  17.             Clist.add(new column_t("stardcolumninsuper1","stardcolumn1".getBytes(),System.currentTimeMillis()));
  18.             Clist.add(new column_t("stardcolumninsuper2","stardcolumn2".getBytes(),System.currentTimeMillis()));
  19.             //产生一个superColumn元素
  20.             String superColumnName = "superColumn3";
  21.             superColumn_t sct = new superColumn_t(superColumnName , Clist);
  22.             //将这个元素装入到一个superColumn_t的List中
  23.             List<superColumn_t> SClist = new ArrayList<superColumn_t>();
  24.             SClist.add(sct);
  25.             //将这个super_column 的list连同对应的superColumnFamily的名字一起放入一个hashmap中
  26.             Map<String , List<superColumn_t>> cfmap = new HashMap<String , List<superColumn_t>>();
  27.             cfmap.put(superColumnFamilyName, SClist);
  28.             //区别于一般的，这里要求的column元素是superColumn元素
  29.             //将整理好的信息关联一个key后生成一个mutation
  30.             batch_mutation_super_t bmst = new batch_mutation_super_t(tableName,keyName,cfmap);
  31.             boolean block = true;
  32.             //执行这个mutation的插入操作
  33.             cli.batch_insert_superColumn(bmst, block);
  34.        
  35.             //尝试删除之
  36.             cli.remove(tableName, keyName, path, System.currentTimeMillis(), true);
  37.         } catch (InvalidRequestException e) {
  38.             e.printStackTrace();
  39.         } catch (UnavailableException e) {
  40.             e.printStackTrace();
  41.         } catch (TException e) {
  42.             e.printStackTrace();
  43.         }
  44.     }
  45.  

17)//这个方法目前还不健全

  1.  
  2.     public void test_getProperty()
  3.     {
  4.         try {
  5.             //这事一个未健全的方法，现在只能返回对应"tables"的参数，也就是表名
  6.             List<String> Plist = cli.getStringListProperty("tables");
  7.             for(int i = 0 ; i < Plist.size() ; i++){
  8.                 System.out.println(Plist.get(i));
  9.             }
  10.         } catch (TException e) {
  11.             // TODO Auto-generated catch block
  12.             e.printStackTrace();
  13.         }
  14.         //现在只支持如下三个参数
  15.         try {
  16.             System.out.println(cli.getStringProperty("cluster name"));
  17.             //会直接把server端的storage_conf.xml读进来,可能用于做进一步的xml分析
  18.             System.out.println(cli.getStringProperty("config file"));
  19.             System.out.println(cli.getStringProperty("version"));
  20.         } catch (TException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24.  

一些注意的：
1)cli的实例还有一些诸如sent_*和recv_*（成对出现）的公共方法，这些方法是供上面罗列的相应方法调用的，一般不用管，
2)sent_*负责想服务器端发送消息
3)recv_*将处理返回的所要的结果或处理错误信息抛出相应异常
4)大部分方法可执行的前提是必须有一个精确的key信息,(describe_table和get_key_range除外)。
5)一个superColumnFamily中只能存放superColumn_t元素而不能存放column_t元素
6)一个columnFamily中只能存放column_t元素
转：http://blog.csdn.net/pakly_9527/archive/2009/08/14/4447359.aspx

]]> http://www.javagg.com/archives/682/feed 0 cassandra 学习笔记(3) http://www.javagg.com/archives/680 http://www.javagg.com/archives/680#comments Mon, 15 Mar 2010 01:54:20 +0000 纯净水 http://www.javagg.com/?p=680 当某个end point拿到一个key(比如”王老六”)并想取出他的相关信息的时候,这个节点是怎么知道这个key的相关信息是存放在哪些节点中的呢?
以下将用从客户端拿到的”get_clomun”请求为例，进行说明：

      “get_column”的相关信息会在CassandraServer的get_column(String tablename, String key, String columnPath)方法中被封装成一个readCommand实例，该对象简单包含了请求信息，另外也提供了一些别的方法。

      然后该command实例会最终被交给 StorageProxy.readProtocol(command,StorageService.ConsistencyLevel.WEAK)来处理，并期待这个方法能返回一个和key关联的columnFamily的数据，这些数据被装在一个row对象里返回的。

      在上述的StorageProxy.readProtocol(…)这个方法中，首先要做的事情就是根据提交的key(“王老六”)确定他的相关信息内容是存放在那些end point中的。而这个寻找end point的工作由StorageService.instance().getNStorageEndPoint(command.key)来完成。

      实际上，上述的StorageService的getNStorageEndPoint(String key)方法调用了他持有的实例”nodePicker_”的getStorageEndPoints(Token token) 来完成寻找end point这件事情。

      题外话：StorageService这个实例提供了本地节点数据存储和与其他节点交互的服务，这个实例是在节点启动之初被建立的，在建立的时候该实例会初始化一个nodePicker_放在其内部，这个nodePicker主要负责本地节点同其他节点的交互规则，也就是如何选择其他节点的策略。当前的策略有两种:RackAwareStrategy–机架敏感 和 RackUnawareStrategy–非机架敏感，默认策略是RackUnawareStrategy。

      所以默认情况下，nodePicker_就是一个RackUnawareStrategy实例，而他的 getStorageEndPoints(Token token)将被用来查找合适我们给出的key(“王老六”)的end point,这里合适的意思是“存有关于这个key的信息”。而这里提到的token是由key封装得来的，他对key进行了hash，并且继承了 Comparable接口。也就是说，这个token实例是可以和其他同类token比较大小的，而这样做的目的是为了“可以在Token组成的list 上进行二分查询Collection.binarySort，并定位查找目标的在list中的相对位置”–这种查找操作将被经常使用。默认情况下 token是一个BigIntegerToken的实例。

      nodePicker_最终会将查找的工作交给getStorageEndPoints(Token token, Map<Token, EndPoint> tokenToEndPointMap)来做，这个方法会返回一个查找到的end_point的数组。以下是对RackUnawareStrategy中的相应方法的说明（因为默认是使用这个方法）:
//此处的tokenToEndPointMap保存了该节点知道的所有其他节点，并且可以根据他们的token查找到

//此处的token是我们要查找的key(“王老五”)生成的token,他跟上面end point的token生成的算法是相同的，也都是BigIntegerToken

  1.  
  2. public EndPoint[] getStorageEndPoints(Token token, Map<Token, EndPoint> tokenToEndPointMap)
  3.     {
  4.         //根据key寻址的切入点
  5.         int startIndex;
  6.         List<EndPoint> list = new ArrayList<EndPoint>();
  7.         int foundCount = 0;
  8.         //将key的set装入一个ArrayList中，并完成排序，（一位token是comparable的）
  9.         List tokens = new ArrayList<Token>(tokenToEndPointMap.keySet());
  10.         Collections.sort(tokens);
  11.         //在排好序的tokens中二叉树搜索token，并返回token所在的位置的index
  12.  
  13.         //个人认为:根本别指望tokens里面能有我们要找的token，因为一个是end point的token集合,一个是查找key("王老六")生成的 
  14.  
  15.         //token，生成的时候都使用了hash，并且加入了大随即数，重合的概率很低。
  16.  
  17.         //这样做的主要目的是为了获得下面这个index，（参见binarySearch的说明可知）。
  18.  
  19.         //也就是：虽然下面这条语句不大可能从tokens中取出东西，但是生成的index将告诉我们，哪个end point的token离我们给出的
  20.  
  21.         //key"王老六"的token“最近”。而且，在节点情况固定下来的情况下，用当前这种方法，
  22.  
  23.         //key"王老六"的token确定的对应的end point也是不会改变的(每次都会取到这个end point，除非end point本身注册的变了)。
  24.  
  25.         //也就是说：这就成了一种方法，一种能够根据数据key("王老六")定位到一个end point的方法，
  26.  
  27.         //如果写数据时使用了这种策略找到一个end point 节点然后写进数据，那么手持相应的key在读数据的时候，同样使用这个策略，也
  28.  
  29.         //相应的能找到当时存入数据的那个节点，并把数据读出来。
  30.           int index = Collections.binarySearch(tokens, token);
  31.         //基本上这个条件里面的语句肯定会被执行
  32.  
  33.         //那如果真的用key("王老六")从tokens中找到对应了呢？这个方法里的策略就是，那就直接拿这个被确定的节点来当 “邻居”节点了
  34.  
  35.         //而key的tokens和end_point的token之所以能混在一起说话，是因为他们都是BigIntegerToken，在同一个数据空间中
  36.         if(index < 0)
  37.         {
  38.  
  39.             //以下的运算将把key("王老六")的"邻居"节点给"翻译"出来
  40.             index = (index + 1) * (-1);//得到可以插入的位置
  41.             if (index >= tokens.size())
  42.                 index = 0;
  43.         }
  44.         int totalNodes = tokens.size();
  45.         // Add the node at the index by default
  46.  
  47.         //把我们找到的"邻居"节点放到一个要返回的list中，当然,对于一个key("王老六")的信息还可能在其他节点上存有副本(replicas)
  48.  
  49.         //再下面的操作会将这些存有副本的节点也一同取出
  50.         list.add(tokenToEndPointMap.get(tokens.get(index)));
  51.         foundCount++;
  52.         //本来index是从0…一直到size()的一条线，如果我们用如下的方式选取index，就好似将所有的index数值放在了一个圆圈上，然后按
  53.  
  54.         //从小到大的方向在选取下一个index。startIndex就是一个切入点，本质上Partitioner提供了这个可被"切入"的结构和线索
  55.  
  56.         //猜想这也是为什么叫Partitioner的原因吧
  57.         startIndex = (index + 1)%totalNodes;
  58.         // If we found N number of nodes we are good. This loop will just exit. Otherwise just
  59.         // loop through the list and add until we have N nodes.
  60.         // replicas_对应storage-conf.xml中的最大副本数量
  61.    
  62.  
  63.         //将存有副本的节点也一同取出，就是最初"邻居"节点往后的若干个节点，具体若干几个是在storage-conf.xml的
  64.  
  65.         //<ReplicationFactor>标签中定义的
  66.         for (int i = startIndex, count = 1; count < totalNodes &amp;&amp; foundCount < replicas_; ++count, i = (i+1)%totalNodes)
  67.         {
  68.             if( ! list.contains(tokenToEndPointMap.get(tokens.get(i))))
  69.             {
  70.                 list.add(tokenToEndPointMap.get(tokens.get(i)));
  71.                 foundCount++;
  72.             }
  73.         }
  74.  
  75.         //统一下节点监听端口的信息
  76.         retrofitPorts(list);
  77.         return list.toArray(new EndPoint[list.size()]);
  78.     }
  79.  

转：http://blog.csdn.net/pakly_9527/archive/2009/08/14/4446665.aspx

]]> http://www.javagg.com/archives/680/feed 0 cassandra 学习笔记(2) http://www.javagg.com/archives/678 http://www.javagg.com/archives/678#comments Mon, 15 Mar 2010 01:53:23 +0000 纯净水 http://www.javagg.com/?p=678 源码中对节点的如下称呼应该是等价的: end point , node ,  machine , datacenter , host。

    cassandra节点的启动main()在类org.apache.cassandra.service.CassandraDaemon中，细节在 setup()中。过程中会start一个CassandraServer的实例peerStorageServer。 peerStorageServer在建立的时候，内部会实例化一个 StorageService实例，在该StorageService实例初始化的过程中，该节点的所有功能服务会被配置激活，这些操作是在 StorageService的默认构造器中完成的。

    StorageService的构造器中大致做了如下几件事情：

    1)生成一个storageLoadBalancer_s实例负责负载均衡，现在还没有明白原理。

    2)生成一个endPointSnitch_实例，这个提供了对两个end_point进行比较的一个途径，基本上是判断两个end_point是不是同一个ip等

    3)启动了MessagingService，并且注册了一些handler实例。MessagingService是负责该end_point与其他end_point进行通信的。两个节点间通信的内容被封装在一个Message的实例里面。

       比如，如果节点A想向节点B获得一定的数据，那么A需要通过自己的MessageService向节点B发送一个Message实例，这个实例里面包含了如下信息：这个请求的类型（属于什么stage） ，这个请求要调用的B的哪个handler来处理，以及这个请求的其他具体内容。当节点B接收到节点A发送过来的Message实例后，会将根据这个 Message实例内部指定的handler信息,将该实例转发相应的handler去处理。当然这样做的前提是这个指定的handler已经在B节点注册了，而这个注册过程就是在StorageService启动的时候完成的。

    4)consistencyManager_：还没明白什么意思。

    5)StageManager的配置：

       这个stage的概念来自于“SEDA“( staged event driven architecture)中的”S”,参考http://www.eecs.harvard.edu/~mdw/papers/seda-sosp01.pdf。

       大致意思好像是可以将一个工作流程分为若干个阶段(stage)，然后给各个stage动态的分配线程资源来处理stage内定义的逻辑。stage和 stage之间的通信是通过任务队列完成的，当一个stage的逻辑执行完后，如果需要调用下一个stage来继续执行，那么就往下一个stage保有的任务队列中写入必要的任务信息。

       这样的SEDA结构的好处是：在实际的运行当中各个stage的忙闲程度是不一样的，可以通过将比较闲的stage上的线程资源分配给同期比较忙的stage来实现效率上的提高。

       在cassandra中，还是以3)中例子说明，在A节点发往B节点的Message实例中有一个“这个请求的类型”的信息，这个信息保存在 Message实例内header实例的type_上，是一个字符串。这个字符串标明了当MessageService获取了Message实例后究竟由那个 stage来负责执行指定的handler对象。因为handler对象只是定义了对Message的处理逻辑，所以需要stage里面的线程来对其进行执行。

       当前的stage只有4种，依次在StroageService的 /* All stage identifiers */标注下被定义，分别负责不同的任务，“ROW-READ-STAGE”是负责读取的，其他的含义还没有完全搞清楚，大概是负责修改，数据压缩和 http后台页面信息接收的。

       StageManager部分的源码还没哟看到，可能是负责各个stage间线程调度的吧。

    6)设置nodepicker_定义了当前节点对周围节点的查询策略，具体的还不清楚

转：http://blog.csdn.net/pakly_9527/archive/2009/08/13/4441540.aspx

]]> http://www.javagg.com/archives/678/feed 0 Digg用NoSQL替代MySQL http://www.javagg.com/archives/668 http://www.javagg.com/archives/668#comments Mon, 15 Mar 2010 01:20:21 +0000 纯净水 http://www.javagg.com/?p=668

继 Twitter和Facebook之后,社交新闻网站Digg决定跟 MySQL说再见，并替换掉它的大部分基础设施组成，Digg将从LAMP（Linux、 Apache、MySQL和Perl/PHP/Python）架构迁移到基于Cassandra的NoSQL架构。

Apache Cassandra是一套开源分布式数据库管理系统，最初由Facebook开发，用于储存特别大的数据。Cassandra是一个混合型的非关系的数据 库，主要特点是它不是一个数据库，而是由一堆数据库节点共同构成的一个分布式网络服务，对Cassandra的一个写操作，会被复制到其它节点上，对 Cassandra的读操作，也会被路由到某个节点上面去读取。

Casandra的使用者现在包括了Rackspace、Digg、Facebook、Twitter、Cisco、Mahalo、Ooyala等等。

开源中国社区为您准备了多款 NoSQL 开源软件，详情请看这里。

本文转自oschina.net    开源中国社区 

]]> http://www.javagg.com/archives/668/feed 0 黑色星期五!!  mysql 数据损坏了~~ http://www.javagg.com/archives/565 http://www.javagg.com/archives/565#comments Sat, 06 Mar 2010 16:10:14 +0000 纯净水 eric_DIARY_105879052 3月5日，真是黑色星期五~~~公司的那台sun v440不知为何突然连不上。

马上打电话给朋友，叫他一起去机房一次

到了后用contorl线连接终端一看，居然关机了~~日呀

打命令重开服务器，顺利~~~

接下来启动mysql。。。结果提示错误，启动失败~~

再次重启mysql终于可以启动了，本想应解决了

用软件连接看看，晕，进不了公司的数据库，只可以进mysql和infoxxxx-sxxx这二个数据库，其它的都进不了

当时脸都绿了~~~~~估计是服务器断电，导致数据库文件损坏了

重启了二次也不行，上网找了好久也没有明确的答案，而且不感乱动现在这样坏数据，因为我们是用innodb的，数据都在ibdata1这个文件中，有3.5g呢，后来让朋友再上网找找办法。

我就把ibdata1这个文件下载下来，先备份一个。

我灵光一闪，想放到我本地的mysql上，把本地的文件换了，看看如何。

开始干！！！！！！！！

建文一个新库，把除了mysql文件夹以外的所有文件删除了

再把原来数据库中的ibdata1文件和对应的数据库文件夹copy到mysql的库目录中

再启动mysql。

接下来打开mysql客户端，神奇的事来了，数据都回来了~~~呵呵

马上在服务器上再做一次。。。不行~~还是打不开，怪了，难道linux和windows的不太一样的么。

最后就把本机备份了一把，再恢复到服务器上。。。

解决了！！！！

ps:这个还没有验证数据有没有损失。。因为也无法验证了。。

后来发现，原因是mysql的infoxxx_scxxxx数据库中的tables表，中的对应DB的表的记录数据坏了，有些记录没有了.

]]> http://www.javagg.com/archives/565/feed 1