3 releases (breaking)

0.3.0 Apr 21, 2019
0.2.0 Mar 11, 2019
0.1.0 Jan 6, 2019

#79 in Database implementations

15 downloads per month


741 lines


EmSeries is an Embedded Time Series database. Designed for small-scale applications, it is meant to handle time series data in much he same way that sqlite handles SQL data.

The project has so far only been outlined. Upcoming expected features:

  • indexing based on time
  • indexing based on tags (like Influx)
  • databases larger than memory
  • out of order data arrival
  • multi-process safety

The actual extent of the features implemened will depend on how I and any others decide to use them.

This library is already available for basic create/read/update/delete usage.


An Embedded Time Series Database

This library provides a low-intensity time series database meant to be embedded inside of an application.

From the signature of the series

pub struct Series<T: Clone + Recordable + DeserializeOwned + Serialize> {

you can know that you must parameterize the series over the data type that you want to store, which must also have several traits implemented.

#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
struct BikeTrip {
datetime: DateTime<Utc>,
distance: Distance,
duration: Duration,
comments: String,

impl Recordable for BikeTrip {
fn timestamp(&self) -> DateTime<Utc> {
fn tags(&self) -> Vec<String> {

Recordable requires implementations for timestamp and tags, both of which can be used for searching for records, and both of which may be used for indexing in the future.

The series can only store a single data type, but you can always store multiple data types by wrapping them into a single enum.

Open the series:

let mut ts: Series<BikeTrip> = Series::open("var/bike_trips.json")
.expect("expect the time series to open correctly");

The series file will be created if it does not already exist. If it does already exist, the existing data will be read into memory and made available.

Note: all of the data is read into memory at once. For human-scale things, this probably takes up very little memory, but this software is not optimized for IoT scale deployments. Additionally, this library assumes only one process is writing to the file. Behavior from more than one process writing to the file is currently undefined.


~64K SLoC