zoukankan      html  css  js  c++  java
  • STSDB 一

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

    以下内容基于stsdb4.dll(4.0.3.0版本)库 , 官方地址:http://stsdb.com/

      1 using System;
      2 using System.Collections.Generic;
      3 
      4 namespace STSDB
      5 {
      6     [Serializable]
      7     public class TStudent
      8     {
      9         public TStudent()
     10         {
     11         }
     12         public string Name { get; set; }
     13         public int Age { get; set; }
     14         public int GroupNumber { get; set; }
     15         public List<TCourse> CourseList { get; set; }
     16     }
     17 }
     18 using System;
     19 
     20 namespace STSDB
     21 {
     22     [Serializable]
     23     public class TCourse
     24     {
     25         public string CourseName { get; set; }
     26         public string Teacher { get; set; }
     27         public int Score { get; set; }
     28     }
     29 }
     30 演示代码:
     31 /*
     32  * 1. STSdb 4.0 是一个开源的NoSQL 数据库和虚拟文件系统,支持实时索引,完全用c#开发的。
     33  * 引擎原理基于WaterfallTree(瀑布树)数据结构搭建
     34  * 
     35  * 
     36  * 2.特性
     37  * 支持几十亿级别的数据存取
     38  * 支持TB级别文件大小
     39  * 实时索引
     40  * 内置压缩
     41  * 内置序列化
     42  * 支持稀疏分散的文件(byte[])
     43  * 存储内存可控
     44  * 支持多线程,且线程安全
     45  *  Storage  engine  instance  is  thread-safe.  Creating  (opening)  XTable  and  XFile  instances  in  one  storage  engine  from 
     46     different threads is thread-safe.
     47     XTable and XFile instances are also thread-safe. Manipulating different XTable/XFile instances from different threads 
     48     is thread-safe.
     49  * 
     50  * 3.缺点
     51  * 不支持事务
     52  * 同时处理所有打开的表
     53  * 
     54  * 支持多种情况下的数据引擎连接
     55    IStorageEngine engine = STSdb.FromMemory();              //从内存中读取
     56    IStorageEngine engine = STSdb.FromStream(stream);        //从数据流中读取
     57    IStorageEngine engine = STSdb.FromHeap(heap);            //从堆栈中读取
     58    IStorageEngine engine = STSdb.FromNetwork(host, port);   //从远程地址读取
     59   
     60  * 
     61  * 
     62  */
     63 
     64 using System;
     65 using System.IO;
     66 using System.Linq;
     67 using System.Collections.Generic;
     68 
     69 namespace STSDB
     70 {
     71     using Newtonsoft.Json;
     72     using STSdb4.Data;
     73     using STSdb4.Database;
     74     using STSdb4.Storage;
     75     using STSdb4.WaterfallTree;
     76     using STSdb4.Remote.Heap;
     77 
     78     class Program
     79     {
     80         static void Main(string[] args)
     81         {
     82             ExecuteCode(WriteData);
     83             ExecuteCode(ReadData);
     84             //ExecuteCode(DatabaseSchemeInfo);
     85 
     86             //ExecuteCode(ReadItem);
     87             //ExecuteCode(DeleteItems);
     88             //ExecuteCode(ReadItem);
     89 
     90             //ExecuteCode(GetRecord);
     91             //ExecuteCode(PageRecord);
     92 
     93             //ExecuteCode(Others);
     94             //ExecuteCode(ReNameTable);
     95 
     96             //ExecuteCode(ExistsTable);
     97             //ExecuteCode(DeleteTable);
     98             //ExecuteCode(ExistsTable);
     99 
    100             #region test
    101             //bool quit = false;
    102             //while (!quit)
    103             //{
    104             //    Console.Write("get item data: ");
    105             //    string demo = Console.ReadLine();
    106             //    switch (demo)
    107             //    {
    108             //        case "Y":
    109             //            break;
    110             //        case "Q":
    111             //            quit = true;
    112             //            break;
    113             //        default:
    114             //            Console.WriteLine("Choose a Word between Y and Q(to quit)");
    115             //            break;
    116             //    }
    117             //}
    118             #endregion
    119 
    120             Console.ReadKey();
    121         }
    122         /// <summary>执行方法</summary>
    123         static void ExecuteCode(Action act)
    124         {
    125             System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
    126             stopwatch.Start();
    127 
    128             act();
    129 
    130             stopwatch.Stop();
    131             TimeSpan timespan = stopwatch.Elapsed;
    132 
    133             Console.WriteLine("运行{0}秒", timespan.TotalSeconds);
    134         }
    135 
    136         /// <summary>
    137         /// 数据库名
    138         /// </summary>
    139         /// <remarks>文件名和扩展名不限制</remarks>
    140         protected static string DataBase = "ClassDB.db";
    141         /// <summary>
    142         /// 学生表名
    143         /// </summary>
    144         protected static string TableName = "tb_student";
    145         /// <summary>
    146         /// 【新】学生表名
    147         /// </summary>
    148         protected static string NewTableName = "new_tb_student";
    149         /// <summary>
    150         /// XFile
    151         /// </summary>
    152         protected static string XFileName = "tb_file";
    153 
    154         #region 基本操作
    155         /// <summary>
    156         /// 创建库,写入数据
    157         /// </summary>
    158         static void WriteData()
    159         {
    160             /*
    161              * ①:没有数据库会自动创建的,默认目录和应用程序目录一致;
    162              * ②:打开表,Key支持组合结构 => OpenXTable<TKey, TRecord>
    163              */
    164             using (IStorageEngine engine = STSdb.FromFile(DataBase)) //
    165             {
    166                 var table = engine.OpenXTable<int, TStudent>(TableName); //167                 //var table2 = engine.OpenXTable<TKey, TTick>("table2"); //支持key嵌套
    168                 for (int i = 0; i < 1000; i++)
    169                 {
    170                     table[i] = new TStudent
    171                     {
    172                         Name = "Jon_" + i.ToString(),
    173                         Age = new Random().Next(25, 30),
    174                         GroupNumber = i + (new Random().Next(310, 399)),
    175                         CourseList = new List<TCourse>()
    176                         {
    177                             new TCourse{
    178                                 CourseName="C#高级编程"+i.ToString(),
    179                                 Teacher="老陈"+i.ToString(), 
    180                                 Score=80
    181                             },
    182                             new TCourse{
    183                                 CourseName="C#函数式程序设计"+i.ToString(),
    184                                 Teacher="老李"+i.ToString(),
    185                                 Score=90
    186                             },
    187                             new TCourse{
    188                                 CourseName="多线程实战应用"+i.ToString(),
    189                                 Teacher="老张"+i.ToString(),
    190                                 Score=95
    191                             },
    192                         }
    193                     };
    194                 }
    195                 engine.Commit();
    196             }
    197         }
    198         /// <summary>
    199         /// 读取数据
    200         /// </summary>
    201         static void ReadData()
    202         {
    203             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    204             {
    205                 var table = engine.OpenXTable<int, TStudent>(TableName); //ITable:IEnumerable对象
    206                 foreach (var item in table)
    207                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
    208 
    209                 Console.WriteLine(table.Count());   //TableName表中有100行数据
    210             }
    211         }
    212 
    213         /// <summary>
    214         /// 
    215         /// </summary>
    216         static void DatabaseSchemeInfo()
    217         {
    218             using (IStorageEngine engine = STSdb.FromFile(DataBase)) //
    219             {
    220                 IDescriptor descriptor = engine[TableName];
    221                 Console.WriteLine(descriptor.CreateTime.ToString("yyyy-MM-dd HH:mm:ss"));
    222                 Console.WriteLine(descriptor.ModifiedTime.ToString("yyyy-MM-dd HH:mm:ss"));
    223                 Console.WriteLine(descriptor.Name);
    224                 //ID是表的唯一标识id,表一旦创建,它就创建了,后面只要表在就不会修改
    225                 //重建表它会从新分配
    226                 Console.WriteLine(descriptor.ID);
    227 
    228                 //...
    229             }
    230         }
    231 
    232         /// <summary>
    233         /// 读取单条数据
    234         /// </summary>
    235         static void ReadItem()
    236         {
    237             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    238             {
    239                 var table = engine.OpenXTable<int, TStudent>(TableName); //ITable: IEnumerable对象
    240                 //var item = table.FirstOrDefault(x => x.Key <= 15 && x.Key >= 10);        //key是5的记录
    241                 //table[10];
    242                 var item = table.FirstOrDefault(x => x.Key == 5);        //key是5的记录
    243                 if (item.Value != null)
    244                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
    245                 else
    246                     Console.WriteLine("key = 5 的记录不存在!");
    247                 //Console.WriteLine("10<= key <= 15 的记录不存在!");
    248             }
    249         }
    250 
    251         static void AddItems()
    252         {
    253             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    254             {
    255                 var table = engine.OpenXTable<int, TStudent>(TableName);
    256                 //table[100] = new TStudent(){....};
    257                 table.InsertOrIgnore(2, new TStudent());
    258 
    259                 engine.Commit();
    260             }
    261         }
    262 
    263         /// <summary>
    264         /// 删除表数据
    265         /// </summary>
    266         static void DeleteItems()
    267         {
    268             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    269             {
    270                 var table = engine.OpenXTable<int, TStudent>(TableName); //ITable:IEnumerable对象
    271                 if (table != null)
    272                 {
    273                     //table.Clear();          //清空表数据
    274                     table.Delete(5);        //删掉key是5的记录
    275                     //table.Delete(10, 15);  //删掉key从10到15的记录
    276                     engine.Commit();        //提交操作,不能少
    277                 }
    278             }
    279         }
    280 
    281         /// <summary>
    282         /// 按需获取数据
    283         /// </summary>
    284         static void GetRecord()
    285         {
    286             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    287             {
    288                 /*
    289                    Forward向前读取, Backward向后读取, 它们都有2个重载,下面重点说明第二个重载
    290                  * Forward(TKey from, bool hasFrom, TKey to, bool hasTo);
    291                  * Backward(TKey to, bool hasTo, TKey from, bool hasFrom);
    292                  * 超出范围的都不会排除,另外,查询范围超出也不会有影响,但是要注意一点,formkey和endkey的大小关系
    293                  * 
    294                  * 0<----------[(S)]----------------[(E)]------------->N
    295                  * 
    296                  */
    297                 var table = engine.OpenXTable<int, TStudent>(TableName);
    298                 var fiterTB = table.Forward(2, true, 9, true);    //索引从2到9
    299                 //var fiterTB = table.Forward(2, false, 9, true);   //索引从0到9
    300                 //var fiterTB = table.Forward(2, false, 9, false);  //索引从0到表结尾
    301                 //var fiterTB = table.Forward(2, true, 9, false);   //索引从2到表结尾
    302                 //Backward刚好相反
    303                 foreach (var item in fiterTB)
    304                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
    305             }
    306         }
    307         /// <summary>
    308         /// 数据分页
    309         /// </summary>
    310         static void PageRecord()
    311         {
    312             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    313             {
    314                 int pageIndex = 2;
    315                 int pageSize = 10;
    316 
    317                 var table = engine.OpenXTable<int, TStudent>(TableName);
    318                 var fiterTB = table.Skip(pageSize * (pageIndex - 1)).Take(pageSize);
    319                 foreach (var item in fiterTB)
    320                     Console.WriteLine(JsonConvert.SerializeObject(item, Newtonsoft.Json.Formatting.Indented));
    321             }
    322         }
    323         /// <summary>
    324         /// 文件数和记录数
    325         /// </summary>
    326         static void Others()
    327         {
    328             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    329             {
    330                 //表和虚拟文件的数量
    331                 Console.WriteLine("数据库 " + DataBase + " 中有 {0} 张表:{1}", engine.Count, TableName);
    332 
    333                 //表记录数
    334                 var table = engine.OpenXTable<int, TStudent>(TableName);
    335                 Console.WriteLine("" + TableName + "中有" + table.Count() + "条记录");
    336             }
    337         }
    338 
    339         /// <summary>
    340         /// 表是否存在
    341         /// </summary>
    342         static void ExistsTable()
    343         {
    344             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    345             {
    346                 //判断表存在与否
    347                 //bool exists = engine.Exists(NewTableName);
    348                 //Console.WriteLine(NewTableName + " exist?=>{0}", exists.ToString());
    349 
    350                 bool exists = engine.Exists(TableName);
    351                 Console.WriteLine(TableName + " exist?=>{0}", exists.ToString());
    352             }
    353         }
    354 
    355         /// <summary>
    356         /// 重命名表名
    357         /// </summary>
    358         static void ReNameTable()
    359         {
    360             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    361             {
    362                 //判断表存在与否
    363                 bool exists = engine.Exists(TableName);
    364                 Console.WriteLine(TableName + " exist? =>{0}", exists.ToString());
    365 
    366                 //表重命名
    367                 engine.Rename(TableName, NewTableName);
    368                 Console.WriteLine("" + TableName + "被重命名为:" + NewTableName);
    369 
    370                 if (engine.Exists(TableName))
    371                     Console.WriteLine("old table name "" + TableName + "" exist");
    372                 if (engine.Exists(NewTableName))
    373                     Console.WriteLine("new table name "" + NewTableName + "" exist");
    374             }
    375         }
    376         /// <summary>
    377         /// 删除表
    378         /// </summary>
    379         static void DeleteTable()
    380         {
    381             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    382             {
    383                 //删除表
    384                 engine.Delete(TableName);
    385                 //engine.Delete(NewTableName);
    386                 engine.Commit();
    387             }
    388         }
    389         #endregion
    390 
    391         #region XFile
    392 
    393         static void TestXFile()
    394         {
    395             using (IStorageEngine engine = STSdb.FromFile(DataBase))
    396             {
    397                 XFile file = engine.OpenXFile(XFileName);
    398 
    399                 Random random = new Random();
    400                 byte[] buffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    401 
    402                 for (int i = 0; i < 100; i++)
    403                 {
    404                     long position = random.Next();
    405 
    406                     file.Seek(position, SeekOrigin.Begin);
    407                     file.Write(buffer, 0, buffer.Length);
    408                 }
    409                 engine.Commit();
    410             }
    411         }
    412         //XFile uses special XTable<long, byte[]> implementation to provide effective sparse file functionality.
    413         //One storage engine can have many files
    414         #endregion
    415 
    416         #region Client/Server
    417 
    418         static void ClientUpdateData()
    419         {
    420             using (IStorageEngine engine = STSdb.FromNetwork("localhost", 7182))
    421             {
    422                 ITable<int, string> table = engine.OpenXTable<int, string>("table");
    423                 for (int i = 0; i < 100000; i++)
    424                 {
    425                     table[i] = i.ToString();
    426                 }
    427                 engine.Commit();
    428             }
    429         }
    430 
    431         static void ServerHandleData()
    432         {
    433             string _dbname = "test.stsdb4";
    434             using (IStorageEngine engine = STSdb.FromFile(_dbname))
    435             {
    436                 var server = STSdb.CreateServer(engine, 7182);
    437                 server.Start();
    438                 //server is ready for connections
    439                 //server.Stop();
    440             }
    441         }
    442         //The created server instance will listen on the specified port 
    443         //and receive/send data from/to the clients
    444 
    445         #endregion
    446 
    447         #region Memory Usage
    448         /*
    449          min/max children (branches) in each internal (non-leaf) node
    450          max operations in the root node
    451          min/max operations in each internal node
    452          min/max records in each leaf node
    453          number of cached nodes in the memory
    454          */
    455         static void MemoryUsageHandle()
    456         {
    457             using (StorageEngine engine = (StorageEngine)STSdb.FromFile(DataBase))
    458             {
    459                 //下面的demo都是STS.DB的默认值设置
    460 
    461                 //min/max children (branches) in each internal node
    462                 engine.INTERNAL_NODE_MIN_BRANCHES = 2;
    463                 engine.INTERNAL_NODE_MAX_BRANCHES = 4;
    464                 //max operations in the root node
    465                 engine.INTERNAL_NODE_MAX_OPERATIONS_IN_ROOT = 8 * 1024;
    466                 //min/max operations in each internal node
    467                 engine.INTERNAL_NODE_MIN_OPERATIONS = 64 * 1024;
    468                 engine.INTERNAL_NODE_MAX_OPERATIONS = 128 * 1024;
    469                 //min/max records in each leaf node
    470                 engine.LEAF_NODE_MIN_RECORDS = 16 * 1024;
    471                 engine.LEAF_NODE_MAX_RECORDS = 128 * 1024; //at least 2 x MIN_RECORDS
    472                 //number of cached nodes in memory
    473                 engine.CacheSize = 32;
    474             }
    475         }
    476 
    477         #endregion
    478 
    479         #region Heap
    480 
    481         /*using =>
    482             STSdb4.WaterfallTree;
    483             STSdb4.Storage;
    484             STSdb4.Remote.Heap;
    485         */
    486         static void HeaperEngine()
    487         {
    488             //Server端
    489             IHeap heap = new Heap(new FileStream("Heap.db", FileMode.OpenOrCreate));
    490             HeapServer server = new HeapServer(heap, 7183); //监听堆服务器
    491             server.Start(); //开始监听
    492 
    493             //从远程堆中创建 IStorageEngine 引擎,并处理数据
    494             //using (IStorageEngine engine = STSdb.FromHeap(new RemoteHeap("host", 7183)))
    495             //{
    496             //    ITable<int, string> table = engine.OpenXTable<int, string>("table");
    497             //    for (int i = 0; i < 100000; i++)
    498             //    {
    499             //        table[i] = i.ToString();
    500             //    }
    501             //    engine.Commit();
    502             //}
    503         }
    504         #endregion
    505 
    506         //...
    507 
    508     }
    509 }
  • 相关阅读:
    Delphi 连接 Paradox
    编译MangosZero
    关于StartCoroutine的简单线程使用
    cocos2dc-x解决中文乱码
    C++类构造函数初始化列表
    dynamic_cast
    cocos2d-x for android:SimpleGame分析
    C++宏定义详解
    四 AndEngine 画线
    三 最简单的 AndEngine 程序框架
  • 原文地址:https://www.cnblogs.com/jackrebel/p/7388038.html
Copyright © 2011-2022 走看看