* 使用基于Key/Value 接口的场合，可以考虑Berkeley DB C版本或者Berkeley DB Java 版的产品。可以参考美国University of Virginia的叫做PRIDE的学术论文：http://www.cs.virginia.edu/~stankovic/psfiles/pride.pdf

* 使用Oracle Berkeley DB SQL产品中的R*Tree功能，具体可以参考：http://www.bdbchina.com/2010/04/bdb11gr2的r-tree功能/

更多反馈，欢迎留言。

R-Tree是一种和BTree类似的数据结构，支持高维数据的快速检索，被广泛应用于各种空间数据中。R-Tree的一个典型的应用是从许多空间对象的信息中找出用户关心的那个。如给定一座城市各个建筑物的经纬度坐标并存储于R-Tree中，用户可以通过“查找当前位置向西五公里内的所有餐厅”，“查找会展中心方圆一公里内的所有汽车站”等方式来查询自己感兴趣的某些特定建筑。

2 BDB11gR2的R-Tree功能

新发布的BerkeleyDB 11gR2(以下简称BDB11gR2）版本能够无缝地兼容SQLite的接口，从而支持各种基于SQLite的应用，包括SQLite自带R-Tree扩展应用。关于SQLite的R-Tree细节，可参见http://www.sqlite.org/rtree.html。
下面，本文将从编译和使用两方面，介绍如何在BDB11gR2中使用R-Tree功能。

2.1 编译

BDB11gR2通过编译开关控制是否启用R-Tree功能。默认情况下，BDB11gR2是不启用R-Tree的。要获得R-Tree的支持，则应该在编译时加上SQLITE_ENABLE_RTREE标志。

Linux平台

cd build_unix
../dist/configure CPPFLAGS=-DSQLITE_ENABLE_RTREE --enable-sql
make dbsql


Windows平台

在工程文件的属性中，选择 Properties -> Configuration Properties -> c/c++ -> Command Line -> Additional Options, 加入/D DSQLITE_ENABLE_RTREE，并重新编译工程。

2.2 使用R-Tree

一棵R-Tree实际上对应于一张虚拟表。建立R-Tree索引的过程，实际上就是建立虚拟表的过程。和普通表类似的，我们也可以对这张特殊的虚拟表进行插入，删除，更新等操作。

我们以下面这张图为例来说明R-Tree的典型操作和应用。

在图1中，有三个蓝色的矩形，代表三个建筑的边界，标记为1，2，3。它们的坐标信息如图所示。我们要建立一棵R-Tree，来存储这些矩形的坐标信息，并在此基础上进行一些简单的查询。

建立R-Tree索引

CREATE VIRTUAL TABLE demo_index USING rtree(
id,
minX, maxX,
minY, maxY
);

以上操作建立了一张R-Tree索引表。该索引表中每一条记录代表了一个矩形框。每条记录由5列组成，其中id是一个整数类型的主键，minX，maxX分别代表矩形框横坐标的最小值和最大值，minY，maxY分别代表矩形框纵坐标的最小值和最大值。注意，BDB11gR2中的R-Tree表的列数必须是3-11之间的基数，其中第一列是表的主键，2k和2k+1列分别代表第k维数据的下界和上界(k=1~5).

插入数据

向R-Tree的表中插入数据，和向普通表中插入数据的语法是完全一致的。
以下三条语句插入了图1中的三个矩形：

INSERT INTO demo_index VALUES(
1,
0, 2,
0, 1
);
INSERT INTO demo_index VALUES(
2,
3, 5,
3, 5
);
INSERT INTO demo_index VALUES(
3,
4, 5,
1, 4
);

基于R-Tree的查询

和普通表类似的，用户卡可以对R-Tree表进行查询。如

SELECT id FROM demo_index
WHERE id=1;

但R-Tree表上更为常用和典型的查询则是范围查询(Range-Query). 举例如下：

SELECT id FROM demo_index
WHERE minX>=0 AND maxX<=3
AND minY>=0 AND maxY<=2;

查询的结果为
1

上面这条查询的含义是找出图1中所有被包含在红色虚线矩形框中的矩形。

SELECT id FROM demo_index
WHERE maxX>=1 AND minX<=4
AND maxY>=0 AND minY<=4;
查询结果为
1
2

上面这条查询的含义是找出图1中所有和黑色虚线矩形框有交集的矩形。

总结

R-Tree在高维数据的检索中有着广泛的应用。各种地理信息，带时间记录的归档信息等，都可以通过建立基于R-Tree的索引，来达到快速检索的目的。欢迎通过使用Berkeley DB11gR2的RTree功能来构建自己的R-Tree索引，若有任何相关问题，请联系  Linchun dot sun at Oracle dot com。

CREATE VIRTUAL TABLE demo_index USING rtree(

   id,               

   minX, maxX,       

   minY, maxY        

);

以上操作建立了一张R-Tree索引表。该索引表一共由5列组成，每一条记录代表了一个矩形框。其中id是一个整数类型的主键，minX，maxX分别代表矩形框横坐标的最小值和最大值，minY，maxY分别代表矩形框纵坐标的最小值和最大值。注意，r-tree的列数n必须为2m+1，其中m为表示对象的维数。

插入数据

在R-Tree的表中插入数据，和往普通表中插入数据的语法是完全一致的。

以下三条语句插入了图1中的三个矩形：

INSERT INTO demo_index VALUES(

1,                   

0, 2,  

0, 1     

);

INSERT INTO demo_index VALUES(

    2,

    3, 5,

    3, 5

);

INSERT INTO demo_index VALUES(

    3,

    4, 5,

    1, 4

);

基于R-Tree的查询

和普通表类似的，用户卡可以对R-Tree表进行查询。如

SELECT id FROM demo_index

 WHERE id=1;

但R-Tree表上更为常用和典型的查询则是范围查询(Range-Query). 

SELECT id FROM demo_index     

 WHERE minX>=0 AND maxX<=3

   AND minY>=0 AND maxY<=2;

查询的结果为

1

这条查询的含义是找出图1中所有被包含在红色虚线矩形框中的矩形。

SELECT id FROM demo_index     

 WHERE maxX>=1 AND minX<=5

   AND maxY>=0 AND minY<=4;

查询结果为

1

2

3

这条查询的含义是找出图2中所有和黑色虚线矩形框有交集的矩形。

本文将展示如何在Ubuntu Linux x32平台上使用完整的Android源代码来编译构建我们的全新Android系统镜像，而Android源代码包中包含了交叉编译器，因此我们不需要事先安装NDK。

1. 编译Android代码

从Android官方网站获取一份Android源代码，这份源代码有2~3G之巨。

在Linux平台上，把源代码解压到$HOME/android/android_src

安装java 1.5版本，(1.6不行)，并设置JAVA_HOME和PATH:

$ export JAVA_HOME=/usr/lib/jvm/java-1.5.0-sun
$ export PATH=$JAVA_HOME/bin:$PATH

先把原始的Android代码完全编译成功(这过程可能要花2~3小时)：

$ cd $HOME/android/android_src
$ . build/envsetup.sh
$ make

可看到生成三个镜像：

Install system fs image: out/target/product/generic/system.img
Target ram disk: out/target/product/generic/ramdisk.img
Target userdata fs image: out/target/product/generic/userdata.img

2. 安装Android SDK并测试镜像

安装Android SDK: http://developer.android.com/sdk/installing.html, 安装目录：$HOME/android/android-sdk-linux_86
安装Android SDK组件: http://developer.android.com/sdk/adding-components.html,选择安装SDK Platform Android 2.1 API 7和Google APIs by Google Inc., Android API 7

用我们编译得到的镜像替换系统的默认镜像。如果需要替换Windows环境下的sdk，那么以下目录”android-sdk-linux_86″相应应该改成 “android-sdk-windows”。

$ cd $HOME/android/android-sdk-linux_86/platforms/android-2.1
$ cp -r images images.bak
$ cp $HOME/android/android_src/out/target/product/generic/*.img images

创建并运行一个新的设备:

$ cd $HOME/android/android-sdk-linux_86/tools/
$ ./android

(如图)使用图形界面工具创建一个Android 2.1的设备BDBSQL,并点击”start”启动。新的设备第一次启动的时间会非常长，这是正常现象。等到Android界面出现，就说明我们的镜像编译基本没问题了。接下来我们进一步把SQLite库替换为BDB。

3. 编译DBSQL

从http://www.oracle.com/technology/software/products/berkeley-db/index.html下载BDB 11gR2源文件(db-5.0.x.tar.gz)，然后

$ cd $HOME/android/android_src/external/sqlite/dist
$ tar zxvf db-5.0.x.tar.gz
$ cp Android.mk Android.mk.bak
$ cp db-5.0.x/build_android/Android.mk .

编辑Android.mk，默认的BDB Log和Region文件大小总和可达到十几兆，因此我们有必要修改Android.mk来减小它(可能需要为Android.mk去掉只读属性)。修改第一处LOCAL_CFLAGS如下所示(相对于默认配置，我们删除了-DSQLITE_OMIT_TRUNCATE_OPTIMIZATION，新增了-DSQLITE_DEFAULT_CACHE_SIZE=256 -DBDBSQL_MAX_LOCKS=1000 -DBDBSQL_MAX_LOCK_OBJECTS=1000)：

LOCAL_CFLAGS += -Wall -DHAVE_USLEEP=1 \
        -DSQLITE_DEFAULT_JOURNAL_SIZE_LIMIT=1048576 \
        -DSQLITE_THREADSAFE=1 -DNDEBUG=1 -DSQLITE_TEMP_STORE=3 \
        -DSQLITE_OS_UNIX=1 \
        -D_HAVE_SQLITE_CONFIG_H -DSQLITE_THREAD_OVERRIDE_LOCK=-1 \
        -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_FTS3_BACKWARDS -Dfdatasync=fsync \
        -DSQLITE_DEFAULT_CACHE_SIZE=256 \
        -DBDBSQL_MAX_LOCKS=1000 \
        -DBDBSQL_MAX_LOCK_OBJECTS=1000

如果确定不会在多进程间共享数据库，还可以在上述LOCAL_CFLAGS中加入”-DBDBSQL_OMIT_SHARING”，这样日志文件不会被写入文件系统，进一步节省了设备空间。

编译系统镜像中的SQLite部分:

$ cd $HOME/android/android_src
$ . build/envsetup.sh
$ make clean-libsqlite
$ mmm -B external/sqlite/dist
$ make snod

编译好了，再来一次镜像替换：

$ cp $HOME/android/android_src/out/target/product/generic/*.img $HOME/android/android-sdk-linux_86/platforms/android-2.1/images

使用图形界面工具删除先前的设备BDBSQL，重创建一个新的Android 2.1设备BDBSQL,并点击”start”启动。这里一定要创建新的设备，因为启动过的设备，其数据库文件已被SQLite生成，DBSQL无法访问。

4. 使用DBSQL

现在Android里所有应用程序的SQL存储引擎都已被替换为DBSQL了。我们使用”联系人”来试用一下我们的新设备吧，在Setting里面把Locate设置为中文简体，安装一个中文输入法(比如搜狗)，然后打开“联系人”，随便增加一条记录：

在主机上我们可以使用adb shell来查看并操作程序所生成的数据库。请留意sqlite3 shell输出的版本信息是Berkeley DB 11gR，同时shell的提示符是dbsql>，这说明我们已经把SQLite成功替换为DBSQL引擎：

$ adb shell
# cd /data/data/com.android.providers.contacts/databases/
# sqlite3 contacts2.db
Berkeley DB 11g Release 2, library version 11.2.5.0.21: (March 30, 2010)
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
dbsql> .tables
_sync_state                       status_updates
_sync_state_metadata              v1_settings
activities                        view_contacts
agg_exceptions                    view_contacts_restricted
android_metadata                  view_data
calls                             view_data_restricted
contact_entities_view             view_groups
contact_entities_view_restricted  view_raw_contacts
contacts                          view_raw_contacts_restricted
data                              view_v1_contact_methods
groups                            view_v1_extensions
mimetypes                         view_v1_group_membership
name_lookup                       view_v1_groups
nickname_lookup                   view_v1_organizations
packages                          view_v1_people
phone_lookup                      view_v1_phones
raw_contacts                      view_v1_photos
settings
dbsql> select * from contacts;
2|逍遥 李|||0|0|0|0|1|1|0nE08B4A8BFA37D4||0
dbsql> select * from data;
1||4|1|0|0|0|li|li|||||||||||||||||
2||6|2|0|0|0|66666666|1||66666666|||||||||||||||
3||6|2|0|0|0|88888888|2||88888888|||||||||||||||
4||8|2|0|0|0|蜀山|1|||||||||||||||||
5||4|2|0|0|0|逍遥 李|逍遥|李||||||||||||||||
dbsql>

5. 结束语

关于DBSQL库在Android平台上的编译和使用的介绍到这里就结束了。我们用两篇博文分别介绍了side-by-side(并存)和Drop-in(替换)这两种使用方式。在Drop-in模式下，现有的应用程序无修改就可以直接使用DBSQL引擎。

DBSQL在开发过程中始终给予Android平台高度重视，在开发过程中投入了多位资深工程师致力于将DBSQL移植到Android平台上，并将Android列为产品周期测试的主流平台。OARDC的工程师Zengfa.Dou和Stephen.Tang给予了我这个初学者极大帮助。在此一并致谢！

本文介绍在Linux平台上如何编译得到适用于Android的DBSQL库，依本文方法编译得到的BDB库将和Android自带的SQLite库并存，我们称其为side-by-side(并存)模式。在这种模式下，Android平台上已有的应用程序还是基于原始的SQLite库，而我们自己编译的应用程序则链接到DBSQL库以获取更高的存储和并发性能。

1. 安装开发环境

(本文假定读者已具备初步的Android Emulator使用经验)
安装SDK
从http://developer.android.com/sdk/index.html下载Android SDK并解压缩得到$HOME/android/android-sdk-linux_86/目录。

安装NDK
从http://developer.android.com/intl/zh-TW/sdk/ndk/index.html下载Linux版Android NDK(android-ndk-r3-linux-x86.zip)并解压缩得到$HOME/android/android-ndk-1.6_r3/目录。

$ cd android-ndk-1.6_r3
$ build/host-setup.sh

安装NDK Wapper
从开心网共享文件夹下载ndk-wrappers.tgz到$HOME/android

$ tar zxvf ndk-wrappers.tgz

ndk-wrapper需要以下变量，因此我们需要把以下变量增加到$HOME/.bashrc并使之生效：

export PATH=$HOME/android/ndk-wrappers/bin:$PATH
$ export NDK_DIR=$HOME/android/android-ndk-1.6_r3
$ export PATH=$HOME/android/android-sdk-linux_86/tools:$PATH
$ . $HOME/.bashrc

(NDK-Wrapper默认使用arm-eabi-gcc 4.2.1, 如果你想使用ndk里面的arm-eabi-gcc 4.4.0，把scripts/env-utils.sh 和setup.sh里面的4.2.1改为4.4.0)

开始安装ndk-wrapper：

$ cd ndk-wrappers
$ ./setup.sh

修改Ndk-Wrapper
修改ndk-wrappers/bin/arm-linux-gcc:

1. 在LINK_FLAGS中增加"-ldl"
2. 删除-fvisibility=hidden

试验Ndk-Wrapper是否可工作

$ arm-linux-gcc --version
arm-eabi-gcc (GCC) 4.4.0
Copyright (C) 2009 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. 编译DBSQL

以下我们使用上面搭建的NDK编译环境来编译适用于Android平台上的DBSQL库。首先从Oracle官网上下载Berkeley DB 11gR2(.tar.gz), 解压并改名为db/

设置CFLAGS

$ export CFLAGS="-DHAVE_USLEEP=1 -DSQLITE_DEFAULT_JOURNAL_SIZE_LIMIT=1048576 \
-DNDEBUG=1 -DSQLITE_TEMP_STORE=3 -DSQLITE_OS_UNIX=1 -D_HAVE_SQLITE_CONFIG_H \
-DSQLITE_THREAD_OVERRIDE_LOCK=-1 -Dfdatasync=fsync -DNO_ANDROID_FUNCS \
-DSQLITE_THREADSAFE=1"

设置为动态编译方式

$ cd db/build_unix
$ ../dist/configure --prefix=$HOME/android/install_db_arm --target=arm-linux \
--host=arm-linux --enable-smallbuild --enable-sql --enable-sql_compat \
--enable-statistics --enable-amalgamation

修改build_unix/db_config.h
每次configure完成后，切记都要编辑build_unix/db_config.h，删除以下两行：

#define HAVE_PREAD 1
#define HAVE_PWRITE 1

开始编译

$ make dbsql

生成的动态库文件为.libs/libdb_sql-5.0.so，Shell文件为.libs/dbsql。

3. 使用DBSQL库

我们使用现成的DBSQL范例来演示如何在自己的程序中使用DBSQL库

编译范例

$ cd  build_unix
$ make ex_sql_query

编译完成后生成范例程序.libs/ex_sql_query /data/bdb

运行范例
启动Android Emulator，上传，并运行DBSQL库和范例

$ adb shell mkdir /data/bdb
$ adb shell mkdir /data/sql/examples/data
$ adb shell mkdir /data/sql
$ adb shell mkdir /data/sql/examples
$ adb shell mkdir /data/sql/examples/data
$ adb push .libs/libdb_sql-5.0.so /data/bdb
$ adb push .libs/ex_sql_query /data/bdb
$ adb push ../sql/examples/data/ /data/sql/examples/data
$ adb shell "cd /data/bdb; export LD_LIBRARY_PATH=/data/bdb; ./ex_sql_query"

现在终端应该已经输出query范例的运行结果了。以下是GUI终端的输出截图：

4. 结束语

至此，关于BDB 11gR2 SQL库的side-by-side编译模式的介绍就结束了。我们可将编译得到的库应用到自己的程序中去。side-by-side模式的优点不改动Android系统底层库和镜像，使用简单。缺点是只能用C/JNI方式调用，无法用Android自带的SQL接口直接调用。而与此对应的是Drop-in模式，Drop-in模式可将Android系统的SQLite层整个替换为BDB 11gR2 SQL，应用程序无修改就可以直接使用，是一种更为强大彻底的应用模式。我们将在后续文章中介绍Drop-in模式的编译方式。

除了对原有Oracle Berkeley DB的功能进行了一定的改进和增强（比如提升了数据压缩功能、性能优化、C/C++中系统资源自动管理功能等等），本次发布的版本中最引人瞩目的变化是我们引入了一个有用的新特性——Oracle Berkeley DB SQL,简称DBSQL (纠正：将原BDBSQL纠正为DBSQL)。这是自Berkeley DB诞生20多年来第一次支持SQL接口。这无论是对开源社区，还是对嵌入式数据库行业来说，都将是一件喜事。在此也感谢整个Oracle Berkeley DB 研发团队的努力工作和大家的不断支持。

新的版本，新增的SQL接口，值得期待。

Oracle Berkeley DB SQL接口简介

从Oracle Berkeley DB (简称BDB)诞生以来，它一直扮演着一个嵌入式、提供API调用的、高性能、非关系型的数据库引擎的角色, 被广泛应用于存储、金融、互联网、电子商务、汽车、消费电子、航空及国防等领域。简言之，它是一个1M大小的C语言类库，提供了基于键/值对（key/value pair）形式的并发和事务操作的API给C/C++/Java/C#/PHP等编程语言调用。由于BDB灵活高效的特点，它特别适合一些大数据量的、或者任务密集型的、或者硬件资源受限而性能要求高的嵌入式、跨平台等等的应用需求。

但我们发现，在很多场合对于关系数据库和SQL的需求是大量存在的。在 “edge”（如消费电子）或者一些大型的企业应用（如ERP）中，一个即时高效、并发的，支持SQL的、本地化嵌入式数据库通常是首选。因此，从 Oracle Berkeley DB 11g release 2开始，我们在保留原有基于key/value操作的API的同时，新增加了对SQL的支持。

DBSQL完全兼容SQLite（著名的嵌入式开源关系数据库）原有的编程接口。以往运行在SQLite上的程序和应用都可以无缝的、方便的迁移到 Oracle Berkeley DB这个更加强大的引擎。并且，Oracle Berkeley DB和SQLite还将进行长期的官方层面的合作，保证了Oracle Berkeley DB的SQL接口和SQLite保持一致，免除了用户的后顾之忧。此外，Berkeley DB SQL完美支持很多第三方的SQLite工具，如JDBC，ODBC，FireFox 3及其SQLite Manager 插件等。

就具体实现来说，在DBSQL中，我们将原SQLite的底层存储引擎替换为Berkeley DB的数据库引擎。如下图所示：

Oracle Berkeley DB SQL 架构图

从上面的DBSQL实现图可以看到，Oracle Berkeley DB引入了SQLite的SQL层：包括用户接口（sqlite3(), ODBC, JDBC等）和SQL语言处理层（Tokenizer、Parser及Generator），而底层引擎（虚拟机）则使用了BDB的存储引擎。从而，将原来SQLite基于数据库级别的并发提升一个级别 - 至BDB的基于页(Page)级别的并发，并可以利用BDB的更好的内存管理、数据和事务恢复功能、更多的扩展（如Berkeley DB的db_hotbackup、db_stat、db_archive等一系列命令行工具）。

Oracle Berkeley DB 11g release 2在主流平台经过了严格的、多重的测试和认证（每个平台涵盖以十万计的测试案例），测试平台包括Solaris、*nix、Windows系列(XP, 7, Mobile)、Android 2.0(及以上)、VxWorks等等。此外，我们还提供了大量工具和资料帮助用户熟悉这套最新接口。随版本一起发布的，包括SQLite到Oracle Berkeley DB数据迁移指南、JDBC/ODBC使用指南、全文检索（Full Text Search）向导、空间数据库（R*Tree）向导、Android平台上使用向导、数据库使用手册及调优向导、数据管理员手册、测试集、代码示例等完善的资料，进一步帮助用户放心地来使用我们的产品。了解更多SQLite的语法、API、命令行等帮助，还可以参考SQLite.org上的文档。

总结一下: DBSQL接口是一个1M大小的C语言类库，是一个高效并发的嵌入式数据库。它支持in-memory cache选项，某些场合可作为内存数据库的一个替代方案。它支持C/C++/Java/PHP等语言接口和通过JDBC/ODBC等驱动程序访问。它运行于Unix/POSIX、Windows家族、VxWorks、QNX、Android等平台。和SQLite一样，它支持SQL92标准。

Berkeley DB SQL和SQLite使用上的区别

a) 对于用户和开发人员来说，这两个产品是没有区别的。它们在SQL语法、API、命令行交互、PRAGAMAs 等方面都是一致的。我认为，用户可以体验的显著区别有可能是性能和并发了 - 由于SQLite提供的是数据库级别的锁，而Berkeley DB SQL是页(Page)级别的锁，因此后者在绝大多数测试中都会快很多 （如Insert, Update, Delete, 并发操作等）。但是，由于DBSQL提供的细粒度锁的机制，它又会带来一些额外的开销，一些极端的测试用例下会比SQLite慢上少许(但不明显)。并且对于这些极端测试的案例，我们一直在进行性能优化。

b) 对于已有的SQLite应用程序和工具而言，由于这两者在调用接口都是一致的，因而都可以无缝支持。

c) 对于DBA人员来说，除了可以继续使用SQLite原来的管理工具，您还可以使用BDB提供的db_hotbackup、db_stat、db_archive等一系列命令行工具来备份，监控，升级等。另外，您还可以联系Oracle寻求支持。

总体而言，我们有充分理由相信Oracle Berkeley DB SQL将会比SQLite更快，更稳定。同时，我们也将会提供更好的支持服务。

DBSQL接口和BDB key/value接口的比较

我们举个例子说明这两套API在开发上的区别。

假设有一个employee的BDB数据库（注：一个BDB的数据库，即相当于关系型数据库中的一张二维表），我们定义其主键字段为：key{empId, email}，定义其value包含字段：value{empName, sex, age, startDate, status}。相应的，对应于Oracle 关系型数据库的表结构为：

TABLE: employee {
empId PRIMARY KEY,
email PRIMARY KEY,
empName,
sex,
age,
startDate,
status
}

接下来，对于数据库的操作，在BDB的语法大致为：
- 要插入一条记录，employeeDatabase.put(key{1000, john.smith@foo.com}, value{'John Smith', 'male', 30, 2005-01-01, 'OK'});
- 随后，如果要更新上面那条记录：employeeDatabase.put(key{1000, john.smith@foo.com}, value{'John Smith', 'male', 60, 2005-01-01, 'Retired'});
- 如果删除该条记录，则：employeeDatabase.delete(key{1000, john.smith@foo.com}); // 此处只需要提供key即可
- 查询记录：employeeDatabase.get(key{1000, john.smith@foo.com}); // 此处只需要提供key即可

在DBSQL中，上面的增删改操作都可以通过标准的SQL语言来进行。如更新一条记录，可写成：

update employee set age=60, status='Retired' where empId=1000 and email='john.smith@foo.com';

总结

最后，需要强调的是，DBSQL是作为对BDB已有功能的一个补充而不是替代。它只是本次BDB发布产品的一个新特性，并且将会像Hash、Queue、集群等功能一样持续下去。它的出现在一定程度上更丰富了BDB的应用场景。用户可以根据自己的需要，选择适合的BDB接口：

• 当用户需要非常高的性能，管理非关系型数据，或者以Queue、Hash等方式来组织和访问数据的时候，可以继续选择 Oracle Berkeley DB的既有key/value API。如大型企业系统中单点登录、消息队列、工作流等模块，如管理XML、声音、照片、视频等场合，如SOA中的BAM模块、业务规则引擎，如云计算或者云存储节点上，等等。
• 而在用户需要一个本地持久化的支持SQL的嵌入式数据库时，DBSQL将成为优先的选择。比如，手机的通讯录、个人web站点、桌面端 的应用（如股票软件、浏览器客户端的缓存和存储）及开发工具（如IDE）、中小企业的数据库系统、企业实时系统的一些缓存模块、小型的关系型内存数据库等 等。

正式版本的Oracle Berkeley DB 11g release 2将于2010年3月底发布。Oracle Berkeley DB整个产品家族继续以开源形式发布，并对开源社区提供支持。更多关于Oracle Berkeley DB 11g release 2的新功能和特性，请关注我们的官方网站（http://www.oracle.com/database/berkeley-db/index.html）或者本博客的后续文章。

请至官方网站下载最新版本的Oracle Berkeley DB数据库系列产品，包括Oracle Berkeley DB （及SQL），Oracle Berkeley DB Java版和Oracle Berkeley DB XML数据库。

更多需求和反馈，欢迎留言或者给我发邮件：chao.huang[at]oracle.com。

内部测试数据（总的指标，包括Berkeley DB以及SQL）：

• 性能：
  • 约以万计(10s of thousands)的Insert/Update/Delete每秒；
  • 约以十万计(100s of thousands)的Select每秒；
  • 约比native SQLite快3倍；
  • 有些极端测试比SQLite慢，但在一个数量级别。
• 并发性
  • 细粒度的锁（Page level locking），保证了更好的并行读/写；
  • TPC-B测试显示，多线程的情形下（比单线程）快6-8倍；
  • 支持数据库运行中的进行数据压缩（database online compact）。
• 可扩展性
  • 单个数据库支持TB级别的数据量；
  • 支持多节点集群。
• 数据同步
  • 可以通过Oracle Mobile Server 10.3向企业端的大型Oracle数据库进行同步；
  • Xcsdasd 的同步客户端。
• SQL功能集
  • SQLite3 API, SQL92标准；
  • ODBC，JDBC标准；
  • 支持Full-Text Search 和R*Tree （Spatial，空间数据库）。
• 运行平台
  • Windows Mobile, 2000, XP, 7
    
  • Andriod
  • VxWorks
  • Linux, Solaris, HP/UX and virtually any *nix variant
    

注意：由于测试不具有代表性和平台环境等差异，这些指标仅供大家参考。

合作伙伴及用户反馈：

• Mike Owens, “The Definitive Guide to SQLite”一书的作者：

Oracle Berkeley DB's new SQLite compatibly offers powerful features for its users and the SQLite community at large. The combination of the two technologies provides developers with tremendous flexibility in a single SQL/API.  Oracle has done a fantastic job of integrating the technologies, and also being an exemplary participant in the open source community by contributing time, expertise and resources to the SQLite project.

• Dr. Richard Hipp, SQLite 数据库的作者及架构师：

Oracle Berkeley DB 11g combines seamlessly the benefits of SQLite’s ubiquitous API with Berkeley DB’s concurrency and performance into an easy-to-use product. SQLite users can now benefit from enhanced concurrency and performance, and Oracle Berkeley DB users can now benefit from an easy-to-use SQL API.

• Liam McLoughlin, Google Chromium OS的开发者：

In my experience Berkley DB 11gR2 is a fully drop-in replacement for SQLite3. I was hugely surprised at just how easy it was; I'd had zero experience in using Berkeley DB in products before, but within a couple hours I had my application powered by Berkeley DB. From there you get all the benefits of Berkeley DB including concurrency and long term stability compared to SQLite3 from an API you're already familiar with. It's quite simply amazing.

• Marie-Anne Neimat, Oracle 数据库产品研发的VP（仿谷歌对VP的解释为：数据库研发全球副总裁）

Mobile applications and mobile infrastructure applications need fast, scalable and reliable storage services - yet must be self-managing and operate without administrators.  With new SQL capabilities and Android support, Oracle Berkeley DB 11g  makes it easier for developers to quickly develop and deploy new ‘edge’ applications that meet users high performance and scalability demands.

• Marco Bambini, SQLabs的CEO

Berkeley DB 11gR2 combines the familiar SQLite API with the powerful, proven Berkeley DB data storage technology. I re-compiled my SQLiteManager product against the Berkeley DB library without any major issues in very little time. I have now a product that is fully able to manage BDB databases without changing a single line of my code. Performance and concurrency are excellent and I am thrilled to think about the future of this great product.

最后，关于Oracle Berkeley DB 11g release 2的更多垂询，欢迎留言或者给我发邮件：chao.huang[at]oracle.com。请至官方网址：http://www.oracle.com/database/berkeley-db/index.html 下载Oracle Berkeley DB 11g release 2。

这些年来，随着大量数据的产生，数据可视化（data visualization）广泛应用于科研、军事、金融、医疗等等领域。我们的生活也到处可见数据可视化的例子。比如，股票软件上显示的K线图，调查结果的柱状图、曲线图，人口分布的密度图等等等等。

那么，什么是数据可视化呢？根据维基百科的解释：Data visualization is the study of the visual representation of data, meaning “information which has been abstracted in some schematic form, including attributes or variables for the units of information”。简单来说，数据可视化就是用更加直观更加生动易懂的图形图像表现某种特定的数据集合。

这篇文章将简单介绍如何轻松利用BDB Java Edition （JE）和prefuse实现自己的数据可视化应用。

可视化工具和数据库的选择

首先我们选择prefuse作为数据可视化工具。prefuse是一个轻量级的用于可视化任意数据集（visualize the data）的java类库，它提供了多种数据可视化模式，比如柱状图、树图、饼图等等。它的优点是简单易用、可视化功能齐全。

但仅仅有可视化工具是不够的，还需要什么呢？当然还必须有存储数据的数据库。可以打个比方，数据是一栋房子，数据可视化就是我们要给房子做装修，让它更好看，那么数据库就是地基。没有地基，何来房子，更不用说装修了。那么，我们选择什么样的数据库呢。既然prefuse是java类库，而我们JE的特点是纯Java实现，性能高，footprint小等等，那么，JE绝对是一个很好的选择。

好了，现在就让我们看看JE + prefuse的威力吧。

数据集属性的定义

首先，我们选择需要做可视化的数据集。在这里，我给出的例子是可视化某个公司的员工数据，包括他们的基本属性，上下级关系和各自所参与的任务。

1. 员工（Employee）的属性

@Entity
public class Employee {
    @PrimaryKey
    int employeeId;

    @SecondaryKey(relate = MANY_TO_ONE)
    String employeeName;

    @SecondaryKey(relate = MANY_TO_ONE)
    float salary;

    @SecondaryKey(relate = MANY_TO_ONE, relatedEntity=Employee.class,
                 onRelatedEntityDelete=NULLIFY)
    int managerId;

    @SecondaryKey(relate = MANY_TO_ONE, relatedEntity=Department.class,
                 onRelatedEntityDelete=NULLIFY)
    int departmentId;

    @SecondaryKey (relate =MANY_TO_MANY, relatedEntity=ServiceRequest.class,
                 onRelatedEntityDelete=NULLIFY)
    Set<Integer> SRIds = new HashSet<Integer>();

    String address;
    String email;
    String phone;

    /* setter and getter functions. */
}

2. 部门（Department）的属性

@Entity
class Department {
    @PrimaryKey
    int departmentId;

    @SecondaryKey(relate = ONE_TO_ONE)
    String departmentName;

    String location;

    /* setter and getter functions. */
}

3. 任务（ServiceRequest）的属性

@Entity
class ServiceRequest {
	@PrimaryKey
	int SRId;

	String title;
	String content;

/* setter and getter functions. */
}

数据可视化效果

我们选择两种可视化方式：弧形树（radial tree）和节点树（node link tree）。下面看看我们的可视化效果。

利用radial tree来显示整个公司的结构（organization chart)：

上图左边最大的窗口显示的是整个公司的结构图。从图中可以看出公司有四个部门。每一个有颜色小节点代表一名员工，不同部门的员工具有不同的颜色。节点之间的连线表示上下级关系。上图右上角的小窗口显示的是选中的员工的具体信息。右下角的小窗口显示的是JE database 的schema图。从中可以看出我们定义了三个Entity: Employee, Department以及Service Request.

点击任意一个员工节点，将可以显示此员工的上下级结构图，也就是在此公司与之有关系的所有员工的结构图。比如我们点击名字叫Goodstein A. Chavez 的员工，结果如下图所示：

从上图可以看出，此员工有四名直接下属，而他的老板直接向公司的CEO汇报。

除了可以直接点击员工节点（基于员工ID）进行查询，我们还可以通过部门ID（Department ID）经理ID（Manager ID）和具体的任务ID（SR ID）和员工姓名来对员工进行查询。下面是对部门ID和任务ID查询的结果截图。

部门2的员工结构图（DeparmentID = 2）

部门2中，参与了任务3的员工（DeparmentID = 2 and SRId = 3）

值得一提的是，所有这些关系的查询都可以利用在JE里面定义的Entity之间的关系（relation），而不需要我们做额外的查询工作，比如想通过经理ID来查询此经理的直接下属，一句代码便可以实现：

dao.employeeByManagerId.subIndex(Integer.valueOf(searchKey)).entities();

JE+prefuse的优势总结

1. 简单易用：用过JE的朋友都知道，利用JE（特别是JE DPL）能够十分轻松、灵活定义各种数据集模型，其get/put操作也特别简单，而且能够很容易写出特定的查询语句。而prefuse也提供了功能齐全的可视化API。所以，利用JE做数据的存取操作，利用prefuse做数据的可视化操作，其对接是十分直接和简便的。
2. Footprint小：拿上面所举的员工数据可视化应用例子来说，整个应用程序打成可直接运行的jar文件才1.87M，但功能却很齐全（多种可视化效果，多种查询方式）。这样大小的程序，即使安装在一般的移动设备（比如手机）上运行都绰绰有余。
3. 性能高：数据可视化的性能主要体现在做查询和可视化的速度。还是以员工数据可视化为例，插入员工数据有1000条，存储到JE 数据库的大小是729k。之后用户对节点的点击和在输入框的查询，其可视化结果都能迅速得以显示（笔者没有做过具体的时间记录，但相信所需时间都是毫秒级的）。

结束语

从这个例子我们可以看出在数据可视化方面，利用JE作为存储引擎是一个很好的选择。有兴趣的朋友不妨一试。另外，这里有一个十分有趣例子，是利用JE和Google Visualization API来可视化一栋房子的用电情况（ electric usage of Hypatia House），感兴趣的朋友请参考以下链接：http://excitedcuriosity.wordpress.com/2010/02/22/its-electric-ted-data-storage-and-plotting/

Oracle Berkeley DB在LinkedIn.com上的新建了一个群，供全球的相关人士（包括工程师、产品经理、客户等）共同讨论Berkeley DB的话题和业界动态。群地址：http://www.linkedin.com/groups?gid=2131985. 欢迎加入！

Oracle Berkeley DB 中国研发团队

Android平台内置的存储数据库（或者说存储引擎）是SQLite。但由于SQLite其自身的一些缺陷，比如非Java语言、并发读写性能不 佳、技术支持困难等等，所以我们的用户倾向于Berkeley DB。我在这里向大家推荐Berkeley DB Java Edition（简称BDB JE）。我们可以把BDB JE的优势（它除了是存Java语言实现外，还有很高的存储性能和良好的并发性支持、Oracle的开发及技术支持团队等等）充分运用到Android 平台上。众所周知，Android平台是类Java语言的，所以，BDB JE对Android平台的开发者而言是一款利器。

以下将手把手教你将BDB JE快速配置到Android平台上（本文，我们用Android在PC机上的模拟器 (avd) 作为实例平台）。

准备工作

• 如果你的电脑上尚未安装Android SDK。那么首先点击这里下载并且安装 Android SDK。Android的官方主页上有详细的如何安装并且启动Android 模拟器（avd）的文档，这里就不再涉及。必须注意的一点是， 将你所安装的Android目录下（假如是<android-installation -home>）的 “tools” 文件夹路径加入到你电脑的路径（path）中去（相信有一定编程经验的读者一定很熟悉如何添加系统路径了），这样，你就可以直接在命令行上运行 Android的各种命令了。

• 点此下载最新版本的BDB JE。解压缩之后（假如你解压路径为JE_HOME/）可以看到在JE_HOME/lib/ 下有一个“je-android-4.0.71.jar”文件。如果找不到，说明你下载的不是最新版本的BDB JE。请到Oracle BDB JE官方网址进行下载：http://www.oracle.com/technology/products/berkeley-db/je/index.html。

• 在开始下面教程之前，我默认大家已经有一定的Android编程基础，如果没有，请大家到Android的官方主页上阅读相关文档（比如，如 何实现“hello world”）.

选择一：在装有Android 插件的Eclipse 编程环境下进行配置

• 如果你编程的IDE是Eclipse，并且你已经在上面安装了Android编程插件（如何在Eclipse上安装Android插件，请看这里），那么就继续阅读本小节以下步骤。注意，我用的是Eclipse3.4.2（Ganymede）版本， 也许不同的版本配置上有稍微的区别。这里建议Eclipse3.4版本以上。

• 打开Eclipse，确认在Windows->Preference->Android下已经写入Android SDK的路径。进入"File->New->Project->Android->Android Project->Next Project"，在弹出的建立project的面板上选择build target（比如Android2.0），并填写Project name (JEExample)、 application name (JEExample)、package name (com.sleepycat.je) 和 activity name (JEExample)。最后点击Finish。Eclipse将会自动帮你生成一个Android工程。假设你所建立的工程路径是<eclipse-je-android-dir>

• 进入”Project->Properties->Libraries->Add External JARs”，在弹出的窗口中选择JE_HOME/lib/je-android-4.0.71.jar。点击OK，你将可以看到在你建立的工程 （JEExample）下面有Referenced Libraries目录，点击之后可以看到je-android-4.0.71.jar。

• 复制代码（这些代码可在下面的"源代码"小节找到）：
  • 将JEExample.java 复制到<eclipse-je-android-dir>/src/com/sleepycat/je
  • 将main.xml 复制到<eclipse-je-android-dir>/ res/layout/main.xml and
  • 将strings.xml 复制到 <eclipse-je-android-dir>/res/values/strings.xml
• 在Eclipse中，打开main.xml，你可以看到在上一步中复制的代码。点击Run，运行JEExample。在正确运行之前，你还需要在 Android上面建立一个用于存储JE数据的文件夹，具体步骤看“在Android模拟器上运行程序”小节中的第一步。

选择二：在非IDE环境下进行配置

• 如果你不喜欢用IDE（如Eclipse)进行编程，只想通过命令行进行配置，请继续阅读本小节以下步骤。

• 首先建立一个Android 的模拟器（AVD）（如果你还没有在你的电脑上建立过Android 的模拟器）：
  • 在命令行运行 android create avd --target 3 --name my_avd （注意，我在这里建立的是Android1.6的模拟器，你也可以建立Android2.0模拟器）
  • 在你想要建立Android工程的目录下面，运行
    • android create project --path JEExample --package com.sleepycat.je --name JEExample --activity JEExample --target 3

    命令运行之后，将在你所在目录下面建立Android工程，文件夹的名称叫做JEExample，其中会有 JEExample/src/com/sleepycat/je/JEExample.java 文件。


• 将JE_HOME/lib/je-android-4.0.71.jar 文件复制到JEExample/libs

• 将三个文件：JEExample/src/com/sleepycat/je/JEExample.java， JEExample/res/layout/main.xml 和 JEExample/res/values/strings.xml 替换成下面“源代码”小节中对应的三个文件：JEExample.java， main.xml 和 strings.xml。

• 进入<android-installation-home>/platforms/android-1.6/tools， 打开 dx.bat 文件， 将其中一行 “REM set javaOpts=-Xmx256M” 改成 “set javaOpts=-Xmx512M“。注意“REM”要去掉。另外，如果你之前建立的Android模拟器 （AVD）是Android2.0，那么就更改android-2.0/tools下的dx.bat文件。

• 运行Android 模拟器：emulator -avd my_avd

• 用命令行进入JEExample目录，然后运行命令
  • ant install

这个命令将会编译JEExample.java ，然后生成JEExample/bin/JEExample-debug.apk ，并将它安装到你所运行的Android 模拟器中。

在Android模拟器上运行示例程序

• 首先，为Android程序建立JE environment 路径，用于存储JE的数据（这一步不可忽略，并且路径名要跟程序一致，否则无法正确运行程序）。具体做法是 ：
  • 在命令行运行adb shell mkdir /data/local/je。或者你首先运行adb shell，然后cd data/local，最后mkdir je。
  • 你也可以删除这个文件夹：rm /data/local/je/*。更多adb shell的命令请参照Android文档。
• 在Android模拟器窗口上点击三角按钮（在Home界面）进入程序列表，在这里你可以看到已经安装上去的 JEExample 程序图标, 点击它，运行JEExample程序。 进入程序之后，在程序界面最上方可以看到  “JEExample”  字样，下面是一个 文字编辑框（TextEdit box）, 还有两个按钮，分别是 “Put Data” 和  “Get Data” 。

• 存数据：
  • 在文字编辑框里输入 key/data 数据对（比如 k1/d1）然后点击 “Put Data” 按钮，这样一条数据（键是k1，值是d1）便存进JE数据库中。

你可以在命令行运行adb shell，进入/data/local/je， 就可以看到JE的存储数据。

• 读数据：
  • 在文字在文字编辑框里输入 你之前存储的键值key（比如k1），然后点击 “Get Data” 按钮，将会弹出“Get Data”的对话框，上面显示你之前存储的数据（比如d1）。

JE示例源代码

• JEExample.java

  
  package com.sleepycat.je;
  
  import android.app.Activity;
  import android.app.AlertDialog;
  import android.content.DialogInterface;
  import android.util.Log;
  import android.os.Bundle;
  import android.view.View;
  import android.widget.Button;
  import android.widget.EditText;
  import android.widget.TextView;
  
  import java.io.File;
  
  import com.sleepycat.je.Database;
  import com.sleepycat.je.DatabaseConfig;
  import com.sleepycat.je.DatabaseEntry;
  import com.sleepycat.je.DatabaseException;
  import com.sleepycat.je.Environment;
  import com.sleepycat.je.EnvironmentConfig;
  import com.sleepycat.je.OperationStatus;
  import com.sleepycat.je.Transaction;
  
  public class JEExample extends Activity {
  
      @Override
      public void onCreate(Bundle icicle) {
          super.onCreate(icicle);
  
          try {
              final File envDir = new File("/data/local/je");
              final EnvironmentConfig envConfig = new EnvironmentConfig();
              envConfig.setTransactional(true);
              envConfig.setAllowCreate(true);
              final Environment env = new Environment(envDir, envConfig);
              final DatabaseConfig dbConfig = new DatabaseConfig();
              dbConfig.setTransactional(true);
              dbConfig.setAllowCreate(true);
              dbConfig.setSortedDuplicates(true);
              final Database db = env.openDatabase(null, "exampledb", dbConfig);
  
              setContentView(R.layout.main);
              final Button button1 = (Button) findViewById(R.id.do_put);
              button1.setOnClickListener(new Button.OnClickListener() {
                  public void onClick(View v) {
  
                      final EditText editText =
                          (EditText) findViewById(R.id.entry);
                      final String keyData = editText.getText().toString();
                      final int idx = keyData.indexOf("/");
                      String key = null;
                      String data = null;
                      String result = null;
                      if (idx < 0) {
                          result = "enter key/data to put";
                      } else {
                          key = keyData.substring(0, idx);
                          data = keyData.substring(idx + 1);
                          result = key + "/" + data;
                          final DatabaseEntry keyEntry =
                              new DatabaseEntry(key.getBytes());
                          final DatabaseEntry dataEntry =
                              new DatabaseEntry(data.getBytes());
  
                          try {
                              final Transaction txn =
                                  env.beginTransaction(null, null);
                              final OperationStatus res =
                                  db.put(txn, keyEntry, dataEntry);
                              if (res != OperationStatus.SUCCESS) {
                                  result = "Error: " + res.toString();
                              }
                              txn.commit();
                          } catch (DatabaseException DE) {
                              result = "Caught exception: " + DE.toString();
                          }
                      }
                      Log.d("JE", "did put of: " + result);
  
                      if (result.contains("Caught exception:")) {
                      	new AlertDialog.Builder(JEExample.this).
                      	    setTitle("Put Data").setMessage(result).
                      	    setPositiveButton("Quit", new DialogInterface.OnClickListener() {
                      		    public void onClick(DialogInterface dialog, int whichButton) {
                      		    }
                      		}).show();
                      } else {
                      	new AlertDialog.Builder(JEExample.this).
                  	        setTitle("Put Data").setMessage("You put the key/data pair: " + result).
                  	        setPositiveButton("Confirm", new DialogInterface.OnClickListener() {
                  		        public void onClick(DialogInterface dialog, int whichButton) {
                  		        }
                  		    }).show();
                      }
                  }
              });
  
              final Button button2 = (Button) findViewById(R.id.do_get);
              button2.setOnClickListener(new Button.OnClickListener() {
                  public void onClick(View v) {
  
                      final EditText editText =
                          (EditText) findViewById(R.id.entry);
                      final String key = editText.getText().toString();
                      final DatabaseEntry keyEntry =
                          new DatabaseEntry(key.getBytes());
                      final DatabaseEntry dataEntry = new DatabaseEntry();
                      String result = null;
                      try {
                          final Transaction txn =
                              env.beginTransaction(null, null);
                          final OperationStatus res =
                              db.get(txn, keyEntry, dataEntry, null);
                          if (res != OperationStatus.SUCCESS) {
                              result = "Error: " + res.toString();
                          } else {
                              result = new String(dataEntry.getData());
                          }
                          txn.commit();
                      } catch (DatabaseException DE) {
                          result = "Caught exception: " + DE.toString();
                      }
                      Log.d("JE", "did get of: " + result);
                      if (result.contains("Caught exception:")) {
                      	new AlertDialog.Builder(JEExample.this).
                  	        setTitle("Get Data").setMessage(result).
                  	        setPositiveButton("Quit", new DialogInterface.OnClickListener() {
                  		        public void onClick(DialogInterface dialog, int whichButton) {
                  		        }
                  		    }).show();
                      } else {
                      	new AlertDialog.Builder(JEExample.this).
                  	        setTitle("Get Data").setMessage("Get result: " + result).
                  	        setPositiveButton("Confirm", new DialogInterface.OnClickListener() {
                  		        public void onClick(DialogInterface dialog, int whichButton) {
                  		        }
                  		    }).show();
                      }
                  }
              });
          } catch (Exception DE) {
              TextView tv = new TextView(this);
              tv.setText("blew chunks " + DE);
              setContentView(tv);
          }
      }
  }
  

• res/layout/main.xml

  
  <?xml version="1.0" encoding="utf-8"?>
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:orientation="vertical"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent"
      >
  
    <TextView android:id="@+id/label"
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:text="JEExample"
      />
  
    <EditText android:id="@+id/entry"
              android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:background="@android:drawable/editbox_background"
              android:layout_below="@id/label"
      />
  
    <Button android:id="@+id/do_put"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/button_put"
      />
  
    <Button android:id="@+id/do_get"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/button_get"
      />
  </LinearLayout>
  

• res/values/strings.xml

  
  <?xml version="1.0" encoding="utf-8"?>
  <resources>
      <string name="app_name">JEExample</string>
      <string name="button_put">Put Data</string>
      <string name="button_get">Get Data</string>
  </resources>

结束语

怎么样，是不是很简单就可以将JE配置到Android中了？你也赶紧试试吧。如果在配置或者安装过程中出错，欢迎给我留言。

注：英文好的同学，可以参照JE最新发布包中的<je-home>/docs/HOWTO-Android.html的英文原文。

英文好的同学，可以读一下我们的授权申明：http://www.oracle.com/technology/software/products/berkeley-db/htdocs/licensing.html。

英文不好的同学，我在此可以稍作解释（强调：我的观点仅作参考，Oracle公司拥有最终解释权）：

1.  Berkeley DB产品家族三大产品（BDB，BDB-JE和BDB-XML）都是采取双license的授权模式，即开源（免费使用）和商用（付费使用）两种模式。

2. 衡量两种授权模式的一个主要区别是 – “redistribute”，意即你是否将自己的应用程序（在你的应用中使用了BDB）发布给第三方，如客户，机构，附属机构，母公司，合作者，中间商，第三方的非营利组织等。

3. 举例子来说：

• 如果是个人用户做学习研究之用，可以选择开源授权，免费；

• 如果是个人用户在BDB上做一些应用，如果你的应用是开源发布的，可以选择开源授权（但要符合BSD、GPL等开源条款）；如果是闭源，需要选择商业授权；

• 如果是在公司的商用项目使用，需要选择商业授权，即付费；

如果大家再有问题，或者不确定，欢迎留言。版权保护，也是保护到每个IT从业人员。

—

附件： Oracle官方网站给出TimesTen和Berkeley DB 产品家族在美国市场参考价格（见下图）。

Berkeley DB 价格清单

关于Oracle产品的价格清单，请浏览官方网址: http://www.oracle.com/corporate/pricing/pricelists.html.

注意： 价格仅作参考，Oracle公司拥有最终解释权。