STSdb

打开数据库并写入数据

using (StorageEngine engine = new StorageEngine("stsdb4.sys", "stsdb4.dat"))
{
    XIndex<int, string> table = engine.OpenXIndex<int, string>("table");
  
    for (int i = 0; i < 1000000; i++)
    {
        table[i] = i.ToString();
    }
  
    table.Flush();
    engine.Commit();
}

读取数据

using (StorageEngine engine = new StorageEngine("stsdb4.sys", "stsdb4.dat"))
{
    XIndex<int, string> table = engine.OpenXIndex<int, string>("table");
  
    foreach (var row in table) //table.Forward(), table.Backward()
    {
        Console.WriteLine("{0} {1}", row.Key, row.Value);
    }
}

Data Transformer

Data transformers are responsible for converting application types to and from IData types. They constitute the transformation layer between XIndex<TKey,TRecord> and XIndex table. All transformers look like:

    public interface IDataTransformer<T>
    {
        IData ToIData(T item);
        T FromIData(IData data);
        DataType DataType { get; }
    }

Each XIndex<TKey,TRecord> instance automatically generates two data transformers – one for the keys and one for the records. In that way every input TKey/TRecord instance is transformed to appropriate IData instance. Similarly, every IData instance from the XIndex is transformed back to TKey/TRecord. (For highly sophisticated types custom transformers can be provided.)

Suppose again that we have the following class:

    public class Tick
    {
        public string Symbol { get; set; }
        public DateTime Timestamp { get; set; }
        public double Bid { get; set; }
        public double Ask { get; set; }
        public long Volume { get; set; }
        public string Provider { get; set; }
    }

If we have XIndex<long, Tick>

IIndex<long, Tick> table = engine.OpenXIndex<long, Tick>("table");

Then the backend XIndex table will be opened with the following two types for the keys and for the records:

Data<long>

Data<string, DateTime, double, double, long, string>

We can open simultaneously the backend XIndex table:

    DataType keyType = DataType.Int64;

    DataType recordType = DataType.Slotes(
        DataType.String,
        DataType.DateTime,
        DataType.Double,
        DataType.Double,
        DataType.Int64,
        DataType.String);

    IIndex<IData, IData> table2 = engine.OpenXIndex(keyType, recordType, "table");

In this case table and table2 will refer to the same data.

If we decide to extend the Tick class with property of non-primitive type (Provider):

    public class Provider
    {
        public string Name { get; set; }
        public string Website { get; set; }
    }

    public class Tick
    {
        public string Symbol { get; set; }
        public DateTime Timestamp { get; set; }
        public double Bid { get; set; }
        public double Ask { get; set; }
        public long Volume { get; set; }
        public Provider Provider { get; set; }
    }

Then the backend XIndex will be opened with the types:

 Data<long>

 Data<string, DateTime, double, double, long, bool, string, string>

We can decide to exclude Symbol and Timestamp and use them as composite key:

public class Key
    {
        public string Symbol { get; set; }
        public DateTime Timestamp { get; set; }
    }
    
    public class Provider
    {
        public string Name { get; set; }
        public string Website { get; set; }
    }

    public class Tick
    {
        //public string Symbol { get; set; }
        //public DateTime Timestamp { get; set; }
        public double Bid { get; set; }
        public double Ask { get; set; }
        public long Volume { get; set; }
        public Provider Provider { get; set; }
    }

IIndex<Key, Tick> table = engine.OpenXIndex<Key, Tick>("table");

Then the backend XIndex will be with types:

Data<string, DateTime>

Data<double, double, long, bool, string, string>

Because data slots can be from primitive types only, an additional Boolean slot is added to indicate whether the Provider property of the current object is null. Thus we decompose user types.

Note: In the future releases slots will be extended to support IData recursively, so the additional slots will be eliminated.

If a XIndex uses composite keys with more than one slot in its Data, the engine compares sub-keys in BigEndian order – from small slot indexes to big one. (The engine automatically generates appropriate comparers for the relevant Data type.)

Transformed to IData user data is very suitable for compression. The engine again automatically generates compression classes for each XIndex type. These classes use parallel vertical compressions for each slot, depending on its primitive type. In that way the compressions are fast, while keeping high compression ratio. By default XIndex<TKey,TRecord> and XIndex keeps the data in compressed format.

XFile

STSdb 4.0 supports sparse files called XFile. We can work with XFile as we are with a standard .NET stream.

using (IStorageEngine engine = STSdb.FromFile("stsdb4.sys", "stsdb4.dat"))
    {
        XFile file = engine.OpenXFile("file");

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

            //writes some data on random positions
            file.Seek(position, SeekOrigin.Begin);
            file.Write(buffer, 0, buffer.Length);
        }

        file.Flush();
        engine.Commit();
    }

XFile uses special XIndex<long, byte[]> implementation and provides effective sparse file functionality. Thus, in one storage engine developers can combine using of XIndex tables and of XFile sparse files.

Client/Server

From the client side, creating a client connection:

using (IStorageEngine engine = STSdb.FromNetwork("localhost", 7182))
    {
        IIndex<int, string> table = engine.OpenXIndex<int, string>("table");

        for (int i = 0; i < 1000; i++)
        {
            table[i] = i.ToString();
        }

        table.Flush();
        engine.Commit();
    }

From the server side, starting the server:

  using (IStorageEngine engine = STSdb.FromFile("stsdb4.sys", "stsdb4.dat"))
    {
        var server = STSdb.CreateServer(engine, 7182);

        server.Start();

        //server is ready for connections

        server.Stop();
    }