`
JadeLuo
  • 浏览: 434739 次
  • 性别: Icon_minigender_1
  • 来自: 珠海
社区版块
存档分类
最新评论

测试连接Sequoiadb

 
阅读更多 
package com.iminido.nosql;

import com.sequoiadb.base.CollectionSpace;
import com.sequoiadb.base.DBCollection;
import com.sequoiadb.base.DBCursor;
import com.sequoiadb.base.Sequoiadb;
import com.sequoiadb.base.SequoiadbDatasource;
import com.sequoiadb.base.SequoiadbOption;
import com.sequoiadb.exception.BaseException;
import com.sequoiadb.net.ConfigOptions;
import ist.Const;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Semaphore;
import java.util.function.BiConsumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.logging.log4j.LogManager;
import org.bson.BSONObject;
import org.bson.BasicBSONObject;
import org.bson.util.JSON;
import org.json.JSONObject;

/**
 * @author Jade
 */
public class Squ {

    private static SequoiadbDatasource sequoiadbDatasource;
    protected static final org.apache.logging.log4j.Logger log = LogManager.getLogger(Squ.class);
    private static Semaphore semaphore = new Semaphore(1);
    private static Map<String, Sequoiadb> dbs = new HashMap<String, Sequoiadb>();

    public static void main(String[] args) {
//
        String connString = Const.SEQUOIADB_HOST + ":" + Const.SEQUOIADB_PORT;
        try {
            // 建立 SequoiaDB 数据库连接
            Sequoiadb sdb = new Sequoiadb(connString, "", "");
            // 获取所有 Collection 信息，并打印出来
            DBCursor cursor = sdb.listCollectionSpaces();
            while (cursor.hasNext()) {
                System.out.println(cursor.getCurrent());
            }
        } catch (BaseException e) {
            System.out.println("Sequoiadb driver error, error description:" + e.getErrorType());
        }

//        initSequoiadbDatasource();
//        getSequoiadb();
//        BSONObject dbo = new BasicBSONObject(); //添加异常处理 
//        dbo.put("key_a", "value_a");
//        dbo.put("key_b", "value_b");
//
//        DBCollection dBCollection = initCollection("test");
//        dBCollection.save(dbo);
//        DBCursor dbc = dBCollection.query();
//        while (dbc.hasNext()) {
//            System.out.println("" + dbc.getNext().toString());
//        }
//        sequoiadbDatasource.close(dBCollection.getSequoiadb());
    }

    static {

    }

    private static void initSequoiadbDatasource() {
        ArrayList<String> urls = new ArrayList<>();
        ConfigOptions nwOpt = new ConfigOptions();          // 定义连接选项
        SequoiadbOption dsOpt = new SequoiadbOption();	    // 定义连接池选项

        urls.add(Const.SEQUOIADB_HOST + ":" + Const.SEQUOIADB_PORT);//
//        urls.add("ubuntu-dev2:11810");
//        urls.add("ubuntu-dev3:11810");

        nwOpt.setConnectTimeout(500);                       // 设置若连接失败，超时时间（ms）
        nwOpt.setMaxAutoConnectRetryTime(0);	            // 设置若连接失败，重试次数

        // 以下设置的都是 SequoiadbOption 的默认值
        dsOpt.setMaxConnectionNum(500);                     // 设置连接池最大连接数
        dsOpt.setInitConnectionNum(10);                     // 初始化连接池时，创建连接的数量
        dsOpt.setDeltaIncCount(10);                        // 当池中没有可用连接时，增加连接的数量
        dsOpt.setMaxIdeNum(10);                             // 周期清理多余的空闲连接时，应保留连接的数量
        dsOpt.setTimeout(5 * 1000);                         // 当已使用的连接数到达设置的最大连接数时（500），请求连接的等待时间。
        dsOpt.setAbandonTime(10 * 60 * 1000);               // 连接存活时间，当连接空闲时间超过连接存活时间，将被连接池丢弃
        dsOpt.setRecheckCyclePeriod(1 * 60 * 1000);         // 清除多余空闲连接的周期
        dsOpt.setRecaptureConnPeriod(10 * 60 * 1000);       // 检测并取回异常地址的周期

        sequoiadbDatasource = new SequoiadbDatasource(urls, Const.SEQUOIADB_USERNAME, Const.SEQUOIADB_PASSWORD, nwOpt, dsOpt); // 创建连接池
    }

    private static synchronized Sequoiadb getSequoiadb() {
        return getSequoiadb("zy");
    }

    private static synchronized Sequoiadb getSequoiadb(String dbName) {
//        Sequoiadb sdb = dbs.get(dbName);
        Sequoiadb sdb = null;
        try {
            sdb = sequoiadbDatasource.getConnection();
        } catch (BaseException | InterruptedException ex) {
            Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);
        }

//        while (sdb == null) {
//            try {
//                semaphore.tryAcquire(1, 2, TimeUnit.SECONDS);
//            } catch (InterruptedException ex) {
//                Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);
//            }
//            try {
//                sdb = sequoiadbDatasource.getConnection();
//            } catch (BaseException | InterruptedException ex) {
//                Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);
//            }
//        }
//        dbs.put(dbName, sdb);
        semaphore.release();
        return sdb;

    }

    private static CollectionSpace initCollectionSpace(String csName) {
        try {
            Sequoiadb sdb = getSequoiadb();
            CollectionSpace cs;
            if (sdb.isCollectionSpaceExist(csName)) {
                cs = sdb.getCollectionSpace(csName);
            } else {
                cs = sdb.createCollectionSpace(csName);
            }
            return cs;
        } catch (BaseException ex) {
            Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        }
    }

    private static DBCollection initCollection(String collectionName) {
        CollectionSpace cs = initCollectionSpace(Const.SEQUOIADB_DATABASE);
        DBCollection cl;
        if (cs.isCollectionExist(collectionName)) {
            cl = cs.getCollection(collectionName);
        } else {
            cl = cs.createCollection(collectionName);
        }
        return cl;
    }

    public static void remove(String collectionName) {
        DBCollection cl = initCollection(collectionName);
        cl.delete(new BasicBSONObject());
        sequoiadbDatasource.close(cl.getSequoiadb());
    }

    public static boolean delete(String cl, String matcher) {
        try {
            DBCollection dbc = initCollection(cl);
            dbc.delete(matcher);
            sequoiadbDatasource.close(dbc.getSequoiadb());
            return true;
        } catch (Exception e) {
            log.error("delete " + cl + "matcher=>" + matcher + "失败", e);
            return false;
        }
    }

    public static void delete(String cl, String matcher, String hint) {
        DBCollection dbc = initCollection(cl);
        dbc.delete(matcher, hint);
        sequoiadbDatasource.close(dbc.getSequoiadb());
    }

    public static boolean insert(String collectionName, String... key_val) {
        String strJson = strs2json(key_val);
        if (strJson != null) {
            BSONObject dbo;
            try {
                dbo = (BasicBSONObject) JSON.parse(strJson); //添加异常处理 
            } catch (Exception e) {
                log.error("解析json字符串异常,传入的字符串为：" + strJson, e);
                return false;
            }

            try {
                DBCollection dbc = initCollection(collectionName);
                dbc.insert(dbo);
                sequoiadbDatasource.close(dbc.getSequoiadb());
                return true;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    public static boolean insert(String collectionName, String strJson) {
        BSONObject dbo = null;
        try {
            dbo = (BasicBSONObject) JSON.parse(strJson); //添加异常处理 
        } catch (Exception e) {
            log.error("解析json字符串异常,传入的字符串为：" + strJson, e);
            return false;
        }

        DBCollection dBCollection = initCollection(collectionName);
        dBCollection.insert(dbo);
        sequoiadbDatasource.close(dBCollection.getSequoiadb());
        return true;
    }

    public static boolean insertNestJson(String collectionName, String strJson, String strJson2, String nameOfNest) {
        BSONObject dbo = null;
        try {
            dbo = (BasicBSONObject) JSON.parse(strJson); //添加异常处理 
        } catch (Exception e) {
            log.error("解析json字符串异常,传入的字符串为：" + strJson, e);
            return false;
        }

        BSONObject dbo2 = null;
        try {
            dbo2 = (BasicBSONObject) JSON.parse(strJson2); //添加异常处理 
        } catch (Exception e) {
            log.error("解析json字符串异常,传入的字符串为：" + strJson, e);
            return false;
        }

        dbo.put(nameOfNest, dbo2);

        DBCollection dBCollection = initCollection(collectionName);
        Object object = dBCollection.insert(dbo);
        sequoiadbDatasource.close(dBCollection.getSequoiadb());
        return true;
    }

    //1
    public static boolean isExist(String collectionName, String matcher) {
        if (null == queryOne(collectionName, matcher, matcher, matcher, null)) {
            return false;
        } else {
            return true;
        }
    }

    public static BasicBSONObject str2BSONObject(String jsonString) {
        return (BasicBSONObject) JSON.parse(jsonString);
    }

    public static List exec(String sql) {
        DBCursor c = null;
        Sequoiadb seq = null;
        try {
            seq = sequoiadbDatasource.getConnection();
            c = seq.exec(sql);
        } catch (BaseException e) {
            e.printStackTrace();
        } catch (InterruptedException ex) {
            Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);
        }

        if (c != null && c.hasNext()) {
            List list = new ArrayList();
            while (c.hasNext()) {
                list.add(c.getNext());
            }
            if (seq != null) {
                sequoiadbDatasource.close(seq);
            }
            return list;
        } else {
            if (seq != null) {
                sequoiadbDatasource.close(seq);
            }
            return null;
        }
    }

    public static String exeSql(String sql) {
        return list2String(exec(sql));
    }

    public static String exe(String sql) {
        return list2String(exec(sql));
    }

    public static boolean execUpdate(String sql) {
        Sequoiadb seq = null;
        try {
            seq = sequoiadbDatasource.getConnection();
            seq.execUpdate(sql);
            sequoiadbDatasource.close(seq);
            return true;
        } catch (BaseException e) {
            sequoiadbDatasource.close(seq);
            e.printStackTrace();
            log.warn(sql, e);
            return false;
        } catch (InterruptedException ex) {
            Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);
            return false;
        }
    }

    private static String _query(String cl, String matcher, String selector, String orderBy, String hint, long skipRows, long returnRows) {
        DBCollection dbc = initCollection(cl);
        String jsonString = cur2jsonstr(dbc.query(matcher, selector, orderBy, hint, skipRows, returnRows));
        sequoiadbDatasource.close(dbc.getSequoiadb());
        return jsonString;
    }

    public static String query(String cl, String matcher, String selector, String orderBy, String hint, long skipRows, long returnRows) {
        return _query(cl, matcher, selector, orderBy, hint, skipRows, returnRows);
    }

    //matcher test
    public static String query(String cl, String matcher) {
        return _query(cl, matcher, null, null, null, 0, 0);
    }

    //matcher test
    public static String query(String cl, String matcher, String selector) {
        return _query(cl, matcher, selector, null, null, 0, 0);
    }

    public static List query4roomids(String cl, String matcher, String selector) {
        DBCollection dbc = initCollection(cl);
        DBCursor dBCursor = dbc.query(matcher, selector, null, null, 0, 0);
        sequoiadbDatasource.close(dbc.getSequoiadb());
        return cur2list(dBCursor);
    }

    //returnRows test
    public static String query(String cl, String matcher, long returnRows) {
        return _query(cl, matcher, null, null, null, 0L, returnRows);
    }

    // selector {filed:1}
    public static String query(String cl, String matcher, String selector, long returnRows) {
        return _query(cl, matcher, selector, null, null, 0L, returnRows);
    }

    // selector {filed:1}
    public static String query(String cl, String matcher, String selector, long skipRows, long returnRows) {
        return _query(cl, matcher, selector, null, null, skipRows, returnRows);
    }

//    orderBy {filed:1/-1}
    public static String query(String cl, String matcher, String selector, String orderBy, long returnRows) {
        return _query(cl, matcher, selector, orderBy, null, 0L, returnRows);
    }

    //hint (index) {}
    public static DBCursor query(String cl, String matcher, String selector, String orderBy, String hint, long returnRows) {
        DBCollection dbc = initCollection(cl);
        DBCursor dbcu = dbc.query(matcher, selector, orderBy, hint, 0L, returnRows);
        sequoiadbDatasource.close(dbc.getSequoiadb());
        return dbcu;
    }

    public static List query2(String cl, String matcher, String selector, String orderBy, String hint, long returnRows, List<String> list) {
        DBCollection dbc = initCollection(cl);
        DBCursor c = dbc.query(matcher, selector, orderBy, hint, 0L, returnRows);

        if (c != null && c.hasNext()) {
            while (c.hasNext()) {
                String str1 = (String) c.getNext().get("acc");
                for (int j = 0; j < list.size(); j++) {
                    String str2 = list.get(j);
                    if (str2.equals(str1)) {
                        list.remove(str1);
                    }
                }
            }
        } else {
            sequoiadbDatasource.close(dbc.getSequoiadb());
            return list;//直接返回生成的推荐号
        }
        sequoiadbDatasource.close(dbc.getSequoiadb());
        return list;
    }

    public static String query(String cl, String matcher, long returnRows, long skipRows) {
        return _query(cl, matcher, null, null, null, skipRows, returnRows);
    }

    //1
    public static BSONObject queryOne(String collectionName, String matcher, String selector, String orderBy, String hint) {
        DBCollection dBCollection = initCollection(collectionName);
        BSONObject bSONObject = dBCollection.queryOne(str2BSONObject(matcher), str2BSONObject(selector), str2BSONObject(orderBy), str2BSONObject(hint), 0);
        sequoiadbDatasource.close(dBCollection.getSequoiadb());
        return bSONObject;
    }

    public static String query(String collectionName) {
        return _query(collectionName, null, null, null, null, 0, 0);
    }

    public static String query(String collectionName, String matcher, String selector, String orderBy, String hint, int limitNum) {
        return _query(collectionName, matcher, selector, orderBy, hint, limitNum, limitNum);
    }

    public static void update(String cl, String matcher, String modifier, String hint) {
        DBCollection dbc = initCollection(cl);
        dbc.update(matcher, modifier, hint);
        sequoiadbDatasource.close(dbc.getSequoiadb());
    }

    public static void update$insert(String cl, String matcher, String modifier, String hint) {
        DBCollection dbc = initCollection(cl);
        dbc.update(matcher, modifier, hint);
        sequoiadbDatasource.close(dbc.getSequoiadb());
    }

    public static void update$unsetAll(String cl, String matcher, String field, String hint) {
        DBCollection dbc = initCollection(cl);
        dbc.update(matcher, "{$unset:" + field + ":[]}", hint); // Squ.update("friend", "{}", "{$unset:{label:[]}}", "{}");
        sequoiadbDatasource.close(dbc.getSequoiadb());
    }

    public static void update$unset(String cl, String matcher, String modifier, String hint) {
        DBCollection dbc = initCollection(cl);
        dbc.update(matcher, "{$unset:" + modifier + "}", hint); //  Squ.update("friend", "{}", "{$unset:{label:[33,44,55]}}", "{}");
        sequoiadbDatasource.close(dbc.getSequoiadb());

    }

    public static void update$addtoset(String cl, String matcher, String modifier, String hint) {
        DBCollection dbc = initCollection(cl);
        dbc.update(matcher, "{$addtoset:" + modifier + "}", hint); //    Squ.upsert("friend", "{}", "{$addtoset:{label:[33,44,55]}}", "{}");
        sequoiadbDatasource.close(dbc.getSequoiadb());
    }

    public static boolean update(String collectionName, String matcher, String modifier) {
        DBCollection dbc = initCollection(collectionName);
        dbc.update(matcher, modifier, null);
        sequoiadbDatasource.close(dbc.getSequoiadb());
        return true;
    }

    public static boolean update$set(String collectionName, String matcher, String modifier) {
        DBCollection dbc = null;
        try {
            dbc = initCollection(collectionName);
            dbc.update(matcher, "{$set:" + modifier + "}", null);
            sequoiadbDatasource.close(dbc.getSequoiadb());
        } catch (Exception e) {
            log.debug("", e);
            sequoiadbDatasource.close(dbc.getSequoiadb());
            return false;
        }

        return true;
    }

    /**
     * 不存在会自动插入新记录
     *
     * @param cl
     * @param matcher
     * @param modifier
     * @param hint
     */
    public static void upsert(String cl, String matcher, String modifier, String hint) {
        DBCollection dbc = initCollection(cl);
        BSONObject ma = null;
        BSONObject mo = null;
        BSONObject hi = null;
        if (matcher != null) {
            ma = (BSONObject) JSON.parse(matcher);
        }
        if (modifier != null) {
            mo = (BSONObject) JSON.parse(modifier);
        }
        if (hint != null) {
            hi = (BSONObject) JSON.parse(hint);
        }
        dbc.upsert(ma, mo, hi);
        sequoiadbDatasource.close(dbc.getSequoiadb());

    }

    public static String strs2json(String... key_val) {
        if (key_val.length % 2 != 0) {

        }
        String strJson = null;
        if (key_val != null) {
            StringBuilder sb = new StringBuilder();
            sb.append("{");
            int i = 0;
            while (key_val[i] != null) {
                sb.append(key_val[i]).append(":\"").append(key_val[++i]).append("\"");
                if (i < key_val.length - 1) {
                    sb.append(",");
                    i++;
                } else {
                    key_val[i] = null;
                }
            }
            sb.append("}");
            strJson = sb.toString();

        }
        return strJson;
    }

    public static List cur2list(DBCursor c) {
        if (c != null && c.hasNext()) {
            List list = new ArrayList();
            while (c.hasNext()) {
                list.add(c.getNext());
            }

            return list;
        }
        return null;
    }

    public static String cur2jsonstr(DBCursor c) {
        String jsonString = "";
        if (c != null && c.hasNext()) {
            while (c.hasNext()) {
                jsonString = jsonString + (c.getNext().toString());
            }
            c.close();
            return jsonString;
        }
        return "{}";
    }

    private static String list2String(List list) {
        if (list != null) {
            StringBuilder sb = new StringBuilder();
            list.stream().forEach((Object s) -> {
                sb.append(s).append(",");
            });
            return sb.toString();
        } else {
            return null;
        }

    }

    public static List<String> queryList(String collectionName, String string, String acc1_id0, String string0, String string1, int i, int DB_SEARCH_REM_COUNT, List<String> list) {
        return query2(collectionName, string, string1, string1, string, i, list);
    }

    public static void remove(String collectionName, String match) {
        DBCollection cl = initCollection(collectionName);
        cl.delete(parse2BasicBSONObject(match));
        sequoiadbDatasource.close(cl.getSequoiadb());
    }

    public static JSONObject parse2JSONObject(String json) {
        return new JSONObject(json);
    }

    static class a implements BiConsumer {

        @Override
        public void accept(Object t, Object u) {
//            System.out.println("t=>>"+t);
//            System.out.println("u=>>"+u);
        }
    }

    public static BasicBSONObject parse2BasicBSONObject(String json) {
        BasicBSONObject bbo = new BasicBSONObject();
        JSONObject obj = parse2JSONObject(json);
//        obj.forEach(new a() {});
        obj.entrySet().forEach(key -> {
            System.out.println("c=>>" + obj.getString(key.getKey()));
            System.out.println("c=>>" + obj.optString(key.getKey()));
        });
        return bbo;
    }

    public static void main2(String[] args) {
        parse2BasicBSONObject("{\n"
                + "  \"_id\":\"testuser8\",\n"
                + "  \"UID\":\"testuser\",\n"
                + "  \"CDATE\":\"2015-05-10 17:28:50\",\n"
                + "  \"IDATE\":\"2015-05-10 17:28:50\",\n"
                + "  \"CARDTL\":\"{\\\"HEADPIC\\\":\\\"\\\",\\\"NICK\\\":\\\"1\\\",\\\"name\\\":\\\"2\\\",\\\"skill\\\":\\\"3\\\"}\",\n"
                + "  \"NICK\":\"\",\n"
                + "  \"NID\":\"8\",\n"
                + "  \"HEADPIC\":\"\",\n"
                + "  \"UDATE\":{\n"
                + "    \"$date\":\"2015-05-10T09:28:50.668Z\"\n"
                + "  },\n"
                + "  \"UD\":\"testuser\",\n"
                + "  \"URID\":\"urid\",\n"
                + "  \"ORANGE\":\"uId:个人信息标签2\"\n"
                + "}");
    }
}

 

分享到：
| java 连接postgresql测试
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    sequoiadb jdbc 驱动 sequoiadb.jar

    sequoiadb jdbc 驱动 sequoiadb.jar sequoiadb java 增删改查， 请看博客: http://ian.wang

    sequoiadb java所用依赖jar包

    2. **连接管理**：使用SequoiaDB Java驱动，首先需要建立与数据库的连接。这通常涉及提供SequoiaDB集群的地址、端口，以及认证信息（用户名和密码）。连接可以通过`SequoiaDBClient`类的`connect()`方法实现。 3. *...

    NoSQL(SequoiaDB&Cassandra&MongoDB)Benchmark性能对比测试报告

    在此次性能对比测试中，bankmarkUG使用了Yahoo Cloud Serving Benchmark（YCSB）作为测试平台，目的是为了比较SequoiaDB、Cassandra和MongoDB在不同工作负载场景下的性能表现。YCSB是一个用于评估云存储系统中数据库...

    SequoiaDB_架构指南

    ### SequoiaDB_架构指南知识点 #### 一、简介 **SequoiaDB（巨杉数据库）**是一款分布式非关系型文档数据库，专为处理海量非关系型数据设计。其核心特点在于分布式架构、高可用性、高性能及对动态数据类型的强大...

    SequoiaDB与Spark在金融行业中的应用

    SequoiaDB和Spark是当前金融行业中较为重要的两种技术应用。SequoiaDB是巨杉数据库，是一款新一代的开源NoSQL数据库，由广州巨杉软件开发有限公司（简称巨杉软件）于2011年推出。它能够处理巨大的数据量，并且支持...

    基于Python的SequoiaDB巨衫数据库设计源码

    本项目标题为“基于Python的SequoiaDB巨衫数据库设计源码”，其描述了一个以Python语言为编程基础的SequoiaDB巨杉数据库设计的源码包。此项目的特点在于它集成了59个文件，这些文件包括了32个Python脚本、7个头文件...

    SequoiaDB 巨衫数据库的 Python 开发包

    SequoiaDB巨衫数据库是一款高性能、高可用性、分布式关系型数据库管理系统，支持SQL和NoSQL数据...通过virtualbox创建的虚拟环境，开发者可以在安全的沙盒中测试和部署SequoiaDB，进一步扩展了在Python开发中的可能性。

    SequoiaDB内存模型.pdf

    SequoiaDB是一款高性能的分布式关系型NoSQL数据库，它的内存模型是其核心架构和优化策略之一。本文将详细介绍SequoiaDB内存模型的三层架构、原理、开发指南、运维指南等知识点。 1. 内存模型架构 SequoiaDB内存模型...

    SequoiaDB架构指南.pdf

    SequoiaDB 架构指南深入解析 SequoiaDB 是一款高性能、大规模分布式数据库系统，专注于处理海量结构化和半结构化数据。本指南旨在详细介绍SequoiaDB的架构和核心特性，帮助读者理解其设计理念，以及如何利用这些...

    SequoiaDB_replsync.pptx

    本文案详细对比 MongoDB，MySQL 和 SequoiaDB 主备同步技术的优缺点； 并详细分析 SequoiaDB 的日志模型，并发同步方案等。

    java后端源码-SequoiaDB:红杉数据库

    SequoiaDB 是一个分布式的面向文档的 NoSQL 数据库。 引擎： sequoiadb -- SequoiaDB Engine sdbstart -- SequoiaDB Engine start sdbstop -- SequoiaDB Engine stop sdblist -- SequoiaDB Engine list sdbfmp -- ...

    分布式数据库 SequoiaDB 初步认识.rar

    分布式数据库SequoiaDB是一种专为大规模数据存储和处理设计的新型数据库系统，它通过将数据分散在多个服务器上，实现了水平扩展的能力，能够处理PB级别的数据量。本篇文章将对SequoiaDB进行初步介绍，包括其核心概念...

    SequoiaDB 巨杉数据库简介

    SequoiaDB 巨杉数据库是一款开源的金融级分布式关系型数据库。

    SequoiaDB巨杉数据库整体框架.pdf

    SequoiaDB巨杉数据库是分布式数据库的代表之一，由两个主要模块构成：数据库存储引擎与数据库实例。这两个模块在功能上相互独立，共同构建了整个SequoiaDB巨杉数据库的运作机制和体系架构。 数据库存储引擎是整个...

    SequoiaDB快速入门

    ### SequoiaDB快速入门知识点解析 #### 一、序言 SequoiaDB是一款分布式NoSQL数据库管理系统，适用于大规模数据存储与管理场景。本文档旨在帮助初学者快速掌握SequoiaDB的基本安装与配置流程。 #### 二、硬件与...

    巨衫数据库在K1 Powerlinux的压力测试.docx

    测试过程中，sysbench向SequoiaDB集群导入32张包含1亿条记录的表，并对SequoiaSQL-MySQL实例施加压力，每个实例连接本地Coord节点。并发请求的数量逐步提升，每次测试持续5分钟。在SequoiaDB的所有组件保持默认配置...

    巨杉数据库SequoiaDB v5.0 发布会直播回放

    巨杉数据库SequoiaDB v5.0 发布会直播回放

    NoSQL Performance Test In - Memory Performance Comparison of SequoiaDB, Cassandra, and MongoDB

    近期， 知名独立基准测评机构bankmark，针对SequoiaDB、MongoDB以及Cassandra三款NoSQL数据库产品做了性能对比测试。在所有的测试中，三款产品的表现各有千秋。 报道详情：http://code.csdn.net/news/2823026

Magicbox
Global site tag (gtag.js) - Google Analytics