STSDB 一

STSdb 4.0 是一个开源的NoSQL 数据库和虚拟文件系统，支持实时索引，完全用c#开发的。
引擎原理基于WaterfallTree（瀑布树）数据结构搭建

以下内容基于stsdb4.dll（4.0.3.0版本）库 ， 官方地址：http://stsdb.com/

 using System;
 using System.Collections.Generic;

 namespace STSDB
 {
     [Serializable]
     public class TStudent
     {
         public TStudent()
         {
         }
         public string Name { get; set; }
         public int Age { get; set; }
         public int GroupNumber { get; set; }
         public List<TCourse> CourseList { get; set; }
     }
 }
 using System;

 namespace STSDB
 {
     [Serializable]
     public class TCourse
     {
         public string CourseName { get; set; }
         public string Teacher { get; set; }
         public int Score { get; set; }
     }
 }
 演示代码：
 /*
  * 1. STSdb 4.0 是一个开源的NoSQL 数据库和虚拟文件系统，支持实时索引，完全用c#开发的。
  * 引擎原理基于WaterfallTree（瀑布树）数据结构搭建
  *
  *
  * 2.特性
  * 支持几十亿级别的数据存取
  * 支持TB级别文件大小
  * 实时索引
  * 内置压缩
  * 内置序列化
  * 支持稀疏分散的文件（byte[]）
  * 存储内存可控
  * 支持多线程，且线程安全
  *  Storage  engine  instance  is  thread-safe.  Creating  (opening)  XTable  and  XFile  instances  in  one  storage  engine  from
     different threads is thread-safe.
     XTable and XFile instances are also thread-safe. Manipulating different XTable/XFile instances from different threads
     is thread-safe.
  *
  * 3.缺点
  * 不支持事务
  * 同时处理所有打开的表
  *
  * 支持多种情况下的数据引擎连接
    IStorageEngine engine = STSdb.FromMemory();              //从内存中读取
    IStorageEngine engine = STSdb.FromStream(stream);        //从数据流中读取
    IStorageEngine engine = STSdb.FromHeap(heap);            //从堆栈中读取
    IStorageEngine engine = STSdb.FromNetwork(host, port);   //从远程地址读取

  *
  *
  */

 using System;
 using System.IO;
 using System.Linq;
 using System.Collections.Generic;

 namespace STSDB
 {
     using Newtonsoft.Json;
     using STSdb4.Data;
     using STSdb4.Database;
     using STSdb4.Storage;
     using STSdb4.WaterfallTree;
     using STSdb4.Remote.Heap;

     class Program
     {
         static void Main(string[] args)
         {
             ExecuteCode(WriteData);
             ExecuteCode(ReadData);
             //ExecuteCode(DatabaseSchemeInfo);

             //ExecuteCode(ReadItem);
             //ExecuteCode(DeleteItems);
             //ExecuteCode(ReadItem);

             //ExecuteCode(GetRecord);
             //ExecuteCode(PageRecord);

             //ExecuteCode(Others);
             //ExecuteCode(ReNameTable);

             //ExecuteCode(ExistsTable);
             //ExecuteCode(DeleteTable);
             //ExecuteCode(ExistsTable);

             #region test
             //bool quit = false;
             //while (!quit)
             //{
             //    Console.Write("get item data: ");
             //    string demo = Console.ReadLine();
             //    switch (demo)
             //    {
             //        case "Y":
             //            break;
             //        case "Q":
             //            quit = true;
             //            break;
             //        default:
             //            Console.WriteLine("Choose a Word between Y and Q(to quit)");
             //            break;
             //    }
             //}
             #endregion

             Console.ReadKey();
         }
         /// <summary>执行方法</summary>
         static void ExecuteCode(Action act)
         {
             System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
             stopwatch.Start();

             act();

             stopwatch.Stop();
             TimeSpan timespan = stopwatch.Elapsed;

             Console.WriteLine("运行{0}秒", timespan.TotalSeconds);
         }

         /// <summary>
         /// 数据库名
         /// </summary>
         /// <remarks>文件名和扩展名不限制</remarks>
         protected static string DataBase = "ClassDB.db";
         /// <summary>
         /// 学生表名
         /// </summary>
         protected static string TableName = "tb_student";
         /// <summary>
         /// 【新】学生表名
         /// </summary>
         protected static string NewTableName = "new_tb_student";
         /// <summary>
         /// XFile
         /// </summary>
         protected static string XFileName = "tb_file";

         #region 基本操作
         /// <summary>
         /// 创建库，写入数据
         /// </summary>
         static void WriteData()
         {
             /*
              * ①：没有数据库会自动创建的，默认目录和应用程序目录一致；
              * ②：打开表，Key支持组合结构 => OpenXTable<TKey, TRecord>
              */
             using (IStorageEngine engine = STSdb.FromFile(DataBase)) //①
             {
                 var table = engine.OpenXTable<int, TStudent>(TableName); //②
                 //var table2 = engine.OpenXTable<TKey, TTick>("table2"); //支持key嵌套
                 for (int i = ; i < ; i++)
                 {
                     table[i] = new TStudent
                     {
                         Name = "Jon_" + i.ToString(),
                         Age = new Random().Next(, ),
                         GroupNumber = i + (new Random().Next(, )),
                         CourseList = new List<TCourse>()
                         {
                             new TCourse{
                                 CourseName="C#高级编程"+i.ToString(),
                                 Teacher="老陈"+i.ToString(),
                                 Score=
                             },
                             new TCourse{
                                 CourseName="C#函数式程序设计"+i.ToString(),
                                 Teacher="老李"+i.ToString(),
                                 Score=
                             },
                             new TCourse{
                                 CourseName="多线程实战应用"+i.ToString(),
                                 Teacher="老张"+i.ToString(),
                                 Score=
                             },
                         }
                     };
                 }
                 engine.Commit();
             }
         }
         /// <summary>
         /// 读取数据
         /// </summary>
         static void ReadData()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 var table = engine.OpenXTable<int, TStudent>(TableName); //ITable:IEnumerable对象
                 foreach (var item in table)
                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));

                 Console.WriteLine(table.Count());   //TableName表中有100行数据
             }
         }

         /// <summary>
         ///
         /// </summary>
         static void DatabaseSchemeInfo()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase)) //①
             {
                 IDescriptor descriptor = engine[TableName];
                 Console.WriteLine(descriptor.CreateTime.ToString("yyyy-MM-dd HH:mm:ss"));
                 Console.WriteLine(descriptor.ModifiedTime.ToString("yyyy-MM-dd HH:mm:ss"));
                 Console.WriteLine(descriptor.Name);
                 //ID是表的唯一标识id，表一旦创建，它就创建了，后面只要表在就不会修改
                 //重建表它会从新分配
                 Console.WriteLine(descriptor.ID);

                 //...
             }
         }

         /// <summary>
         /// 读取单条数据
         /// </summary>
         static void ReadItem()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 var table = engine.OpenXTable<int, TStudent>(TableName); //ITable: IEnumerable对象
                 //var item = table.FirstOrDefault(x => x.Key <= 15 && x.Key >= 10);        //key是5的记录
                 //table[10];
                 var item = table.FirstOrDefault(x => x.Key == );        //key是5的记录
                 if (item.Value != null)
                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
                 else
                     Console.WriteLine("key = 5 的记录不存在！");
                 //Console.WriteLine("10<= key <= 15 的记录不存在！");
             }
         }

         static void AddItems()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 var table = engine.OpenXTable<int, TStudent>(TableName);
                 //table[100] = new TStudent(){....};
                 table.InsertOrIgnore(, new TStudent());

                 engine.Commit();
             }
         }

         /// <summary>
         /// 删除表数据
         /// </summary>
         static void DeleteItems()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 var table = engine.OpenXTable<int, TStudent>(TableName); //ITable:IEnumerable对象
                 if (table != null)
                 {
                     //table.Clear();          //清空表数据
                     table.Delete();        //删掉key是5的记录
                     //table.Delete(10, 15);  //删掉key从10到15的记录
                     engine.Commit();        //提交操作，不能少
                 }
             }
         }

         /// <summary>
         /// 按需获取数据
         /// </summary>
         static void GetRecord()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 /*
                    Forward向前读取, Backward向后读取, 它们都有2个重载，下面重点说明第二个重载
                  * Forward(TKey from, bool hasFrom, TKey to, bool hasTo);
                  * Backward(TKey to, bool hasTo, TKey from, bool hasFrom);
                  * 超出范围的都不会排除，另外，查询范围超出也不会有影响,但是要注意一点，formkey和endkey的大小关系
                  *
                  * 0<----------[(S)]----------------[(E)]------------->N
                  *
                  */
                 var table = engine.OpenXTable<int, TStudent>(TableName);
                 var fiterTB = table.Forward(, true, , true);    //索引从2到9
                 //var fiterTB = table.Forward(2, false, 9, true);   //索引从0到9
                 //var fiterTB = table.Forward(2, false, 9, false);  //索引从0到表结尾
                 //var fiterTB = table.Forward(2, true, 9, false);   //索引从2到表结尾
                 //Backward刚好相反
                 foreach (var item in fiterTB)
                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
             }
         }
         /// <summary>
         /// 数据分页
         /// </summary>
         static void PageRecord()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 int pageIndex = ;
                 int pageSize = ;

                 var table = engine.OpenXTable<int, TStudent>(TableName);
                 var fiterTB = table.Skip(pageSize * (pageIndex - )).Take(pageSize);
                 foreach (var item in fiterTB)
                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
             }
         }
         /// <summary>
         /// 文件数和记录数
         /// </summary>
         static void Others()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 //表和虚拟文件的数量
                 Console.WriteLine("数据库 " + DataBase + " 中有 {0} 张表：{1}", engine.Count, TableName);

                 //表记录数
                 var table = engine.OpenXTable<int, TStudent>(TableName);
                 Console.WriteLine("表" + TableName + "中有" + table.Count() + "条记录");
             }
         }

         /// <summary>
         /// 表是否存在
         /// </summary>
         static void ExistsTable()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 //判断表存在与否
                 //bool exists = engine.Exists(NewTableName);
                 //Console.WriteLine(NewTableName + " exist?=>{0}", exists.ToString());

                 bool exists = engine.Exists(TableName);
                 Console.WriteLine(TableName + " exist?=>{0}", exists.ToString());
             }
         }

         /// <summary>
         /// 重命名表名
         /// </summary>
         static void ReNameTable()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 //判断表存在与否
                 bool exists = engine.Exists(TableName);
                 Console.WriteLine(TableName + " exist? =>{0}", exists.ToString());

                 //表重命名
                 engine.Rename(TableName, NewTableName);
                 Console.WriteLine("表" + TableName + "被重命名为：" + NewTableName);

                 if (engine.Exists(TableName))
                     Console.WriteLine("old table name \"" + TableName + "\" exist");
                 if (engine.Exists(NewTableName))
                     Console.WriteLine("new table name \"" + NewTableName + "\" exist");
             }
         }
         /// <summary>
         /// 删除表
         /// </summary>
         static void DeleteTable()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 //删除表
                 engine.Delete(TableName);
                 //engine.Delete(NewTableName);
                 engine.Commit();
             }
         }
         #endregion

         #region XFile

         static void TestXFile()
         {
             using (IStorageEngine engine = STSdb.FromFile(DataBase))
             {
                 XFile file = engine.OpenXFile(XFileName);

                 Random random = new Random();
                 byte[] buffer = new byte[] { , , , , , , , , ,  };

                 for (int i = ; i < ; i++)
                 {
                     long position = random.Next();

                     file.Seek(position, SeekOrigin.Begin);
                     file.Write(buffer, , buffer.Length);
                 }
                 engine.Commit();
             }
         }
         //XFile uses special XTable<long, byte[]> implementation to provide effective sparse file functionality.
         //One storage engine can have many files
         #endregion

         #region Client/Server

         static void ClientUpdateData()
         {
             using (IStorageEngine engine = STSdb.FromNetwork("localhost", ))
             {
                 ITable<int, string> table = engine.OpenXTable<int, string>("table");
                 for (int i = ; i < ; i++)
                 {
                     table[i] = i.ToString();
                 }
                 engine.Commit();
             }
         }

         static void ServerHandleData()
         {
             string _dbname = "test.stsdb4";
             using (IStorageEngine engine = STSdb.FromFile(_dbname))
             {
                 var server = STSdb.CreateServer(engine, );
                 server.Start();
                 //server is ready for connections
                 //server.Stop();
             }
         }
         //The created server instance will listen on the specified port
         //and receive/send data from/to the clients

         #endregion

         #region Memory Usage
         /*
          min/max children (branches) in each internal (non-leaf) node
          max operations in the root node
          min/max operations in each internal node
          min/max records in each leaf node
          number of cached nodes in the memory
          */
         static void MemoryUsageHandle()
         {
             using (StorageEngine engine = (StorageEngine)STSdb.FromFile(DataBase))
             {
                 //下面的demo都是STS.DB的默认值设置

                 //min/max children (branches) in each internal node
                 engine.INTERNAL_NODE_MIN_BRANCHES = ;
                 engine.INTERNAL_NODE_MAX_BRANCHES = ;
                 //max operations in the root node
                 engine.INTERNAL_NODE_MAX_OPERATIONS_IN_ROOT =  * ;
                 //min/max operations in each internal node
                 engine.INTERNAL_NODE_MIN_OPERATIONS =  * ;
                 engine.INTERNAL_NODE_MAX_OPERATIONS =  * ;
                 //min/max records in each leaf node
                 engine.LEAF_NODE_MIN_RECORDS =  * ;
                 engine.LEAF_NODE_MAX_RECORDS =  * ; //at least 2 x MIN_RECORDS
                 //number of cached nodes in memory
                 engine.CacheSize = ;
             }
         }

         #endregion

         #region Heap

         /*using =>
             STSdb4.WaterfallTree;
             STSdb4.Storage;
             STSdb4.Remote.Heap;
         */
         static void HeaperEngine()
         {
             //Server端
             IHeap heap = new Heap(new FileStream("Heap.db", FileMode.OpenOrCreate));
             HeapServer server = new HeapServer(heap, ); //监听堆服务器
             server.Start(); //开始监听

             //从远程堆中创建 IStorageEngine 引擎，并处理数据
             //using (IStorageEngine engine = STSdb.FromHeap(new RemoteHeap("host", 7183)))
             //{
             //    ITable<int, string> table = engine.OpenXTable<int, string>("table");
             //    for (int i = 0; i < 100000; i++)
             //    {
             //        table[i] = i.ToString();
             //    }
             //    engine.Commit();
             //}
         }
         #endregion

         //...

     }
 }