nosql数据库STSDB的一般性使用

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 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();
 }
 /// 
执行方法
 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);
 }

 /// 

 /// 数据库名
 /// 
 /// 文件名和扩展名不限制
 protected static string DataBase = "ClassDB.db";
 /// 

 /// 学生表名
 /// 
 protected static string TableName = "tb_student";
 /// 

 /// 【新】学生表名
 /// 
 protected static string NewTableName = "new_tb_student";
 /// 

 /// XFile
 /// 
 protected static string XFileName = "tb_file";

 #region 基本操作
 /// 

 /// 创建库，写入数据
 /// 
 static void WriteData()
 {
 /*
 * ①：没有数据库会自动创建的，默认目录和应用程序目录一致；
 * ②：打开表，Key支持组合结构 => OpenXTable
 */
 using (IStorageEngine engine = STSdb.FromFile(DataBase)) //①
 {
 var table = engine.OpenXTable(TableName); //②
 //var table2 = engine.OpenXTable("table2"); //支持key嵌套
 for (int i = 0; i < 1000; i++)
 {
 table[i] = new TStudent
 {
 Name = "Jon_" + i.ToString(),
 Age = new Random().Next(25, 30),
 GroupNumber = i + (new Random().Next(310, 399)),
 CourseList = new List()
 {
 new TCourse{
 CourseName="C#高级编程"+i.ToString(),
 Teacher="老陈"+i.ToString(), 
 Score=80
 },
 new TCourse{
 CourseName="C#函数式程序设计"+i.ToString(),
 Teacher="老李"+i.ToString(),
 Score=90
 },
 new TCourse{
 CourseName="多线程实战应用"+i.ToString(),
 Teacher="老张"+i.ToString(),
 Score=95
 },
 }
 };
 }
 engine.Commit();
 }
 }
 /// 

 /// 读取数据
 /// 
 static void ReadData()
 {
 using (IStorageEngine engine = STSdb.FromFile(DataBase))
 {
 var table = engine.OpenXTable(TableName); //ITable:IEnumerable对象
 foreach (var item in table)
 Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));

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

 /// 

 /// 
 /// 
 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);

 //...
 }
 }

 /// 

 /// 读取单条数据
 /// 
 static void ReadItem()
 {
 using (IStorageEngine engine = STSdb.FromFile(DataBase))
 {
 var table = engine.OpenXTable(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 == 5); //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(TableName);
 //table[100] = new TStudent(){....};
 table.InsertOrIgnore(2, new TStudent());

 engine.Commit();
 }
 }

 /// 

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

 /// 

 /// 按需获取数据
 /// 
 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(TableName);
 var fiterTB = table.Forward(2, true, 9, 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));
 }
 }
 /// 

 /// 数据分页
 /// 
 static void PageRecord()
 {
 using (IStorageEngine engine = STSdb.FromFile(DataBase))
 {
 int pageIndex = 2;
 int pageSize = 10;

 var table = engine.OpenXTable(TableName);
 var fiterTB = table.Skip(pageSize * (pageIndex - 1)).Take(pageSize);
 foreach (var item in fiterTB)
 Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
 }
 }
 /// 

 /// 文件数和记录数
 /// 
 static void Others()
 {
 using (IStorageEngine engine = STSdb.FromFile(DataBase))
 {
 //表和虚拟文件的数量
 Console.WriteLine("数据库 " + DataBase + " 中有 {0} 张表：{1}", engine.Count, TableName);

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

 /// 

 /// 表是否存在
 /// 
 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());
 }
 }

 /// 

 /// 重命名表名
 /// 
 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");
 }
 }
 /// 

 /// 删除表
 /// 
 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[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

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

 file.Seek(position, SeekOrigin.Begin);
 file.Write(buffer, 0, buffer.Length);
 }
 engine.Commit();
 }
 }
 //XFile uses special XTable 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", 7182))
 {
 ITable table = engine.OpenXTable("table");
 for (int i = 0; i < 100000; 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, 7182);
 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 = 2;
 engine.INTERNAL_NODE_MAX_BRANCHES = 4;
 //max operations in the root node
 engine.INTERNAL_NODE_MAX_OPERATIONS_IN_ROOT = 8 * 1024;
 //min/max operations in each internal node
 engine.INTERNAL_NODE_MIN_OPERATIONS = 64 * 1024;
 engine.INTERNAL_NODE_MAX_OPERATIONS = 128 * 1024;
 //min/max records in each leaf node
 engine.LEAF_NODE_MIN_RECORDS = 16 * 1024;
 engine.LEAF_NODE_MAX_RECORDS = 128 * 1024; //at least 2 x MIN_RECORDS
 //number of cached nodes in memory
 engine.CacheSize = 32;
 }
 }

 #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, 7183); //监听堆服务器
 server.Start(); //开始监听

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

 //...

 }
}