storj/satellite/satellitedb/dbx/satellitedb.dbx

// dbx.v1 golang satellitedb.dbx .

//--- containment ---//
model pending_audits (
	key node_id

	field node_id             blob
	field piece_id            blob
	field stripe_index        int64
	field share_size          int64
	field expected_share_hash blob
	field reverify_count      int64 ( updatable )
)

create pending_audits ( )
update pending_audits ( where pending_audits.node_id = ? )
delete pending_audits ( where pending_audits.node_id = ? )
read one (
	select pending_audits
	where  pending_audits.node_id = ?
)

//--- bwagreement ---//

model bwagreement (
	key serialnum

	field serialnum       text
	field storage_node_id blob
	field uplink_id       blob
	field action          int64
	field total           int64
	field created_at      timestamp ( autoinsert )
	field expires_at      timestamp
)


//--- irreparableDB ---//

model irreparabledb (
	key segmentpath

	field segmentpath          blob
	field segmentdetail        blob  ( updatable )
	field pieces_lost_count    int64 ( updatable )
	field seg_damaged_unix_sec int64 ( updatable )
	field repair_attempt_count int64 ( updatable )
)

create irreparabledb ( )
update irreparabledb ( where irreparabledb.segmentpath = ? )
delete irreparabledb ( where irreparabledb.segmentpath = ? )

read one (
	select irreparabledb
	where  irreparabledb.segmentpath = ?
)

read limitoffset (
	select irreparabledb
	orderby asc irreparabledb.segmentpath
)

//--- accounting ---//

// accounting_timestamps just allows us to save the last time/thing that happened
model accounting_timestamps (
	key name

	field name  text
	field value timestamp ( updatable )
)

create accounting_timestamps ( )
update accounting_timestamps ( where accounting_timestamps.name = ? )

read scalar (
	select accounting_timestamps.value
	where  accounting_timestamps.name  = ?
)

model accounting_rollup (
	key id

	field id               serial64
	field node_id          blob
	field start_time       timestamp
	field put_total        int64
	field get_total        int64
	field get_audit_total  int64
	field get_repair_total int64
	field put_repair_total int64
	field at_rest_total    float64
)

create accounting_rollup ( )
delete accounting_rollup ( where accounting_rollup.id = ? )

read one (
	select accounting_rollup
	where  accounting_rollup.id = ?
)

read all (
	select accounting_rollup
	where  accounting_rollup.start_time >= ?
)

//--- statdb ---//

model node (
	key id

	index ( 
		name node_last_ip
		fields last_ip 
	)

	field id             blob
	field address        text  ( updatable ) // TODO: use compressed format
	field last_ip        text  ( updatable )
	field protocol       int   ( updatable )
	field type           int   ( updatable )
	field email          text  ( updatable )
	field wallet         text  ( updatable ) // TODO: use compressed format
	field free_bandwidth int64 ( updatable )
	field free_disk      int64 ( updatable )

 	field major             int64 ( updatable )
	field minor             int64 ( updatable )
	field patch             int64 ( updatable )
	field hash              text ( updatable )
	field timestamp         timestamp ( updatable )
	field release           bool ( updatable )

	field latency_90           int64   ( updatable )
	field audit_success_count  int64   ( updatable )
	field total_audit_count    int64   ( updatable )
	field audit_success_ratio  float64 ( updatable )
	field uptime_success_count int64   ( updatable )
	field total_uptime_count   int64   ( updatable )
	field uptime_ratio         float64 ( updatable )

	field created_at           timestamp ( autoinsert )
	field updated_at           timestamp ( autoinsert, autoupdate )
	field last_contact_success timestamp ( updatable )
	field last_contact_failure timestamp ( updatable )

	field contained bool ( updatable )
)

create node ( )
update node ( where node.id = ? )
delete node ( where node.id = ? )

// "Get" query; fails if node not found
read one (
	select node
	where  node.id = ?
)

read all (
	select node.id
)

read limitoffset (
	select node
	where  node.id >= ?
	orderby asc node.id
)

//--- repairqueue ---//

model injuredsegment (
	key path

	field path text
	field data blob
	field attempted utimestamp (updatable, nullable)
)

//--- satellite console ---//

model user (
    key id

    field id               blob
    field full_name        text      ( updatable )
    field short_name       text      ( updatable, nullable )

    field email            text      ( updatable )
    field password_hash    blob      ( updatable )

    field status           int       ( updatable, autoinsert )

    field created_at       timestamp ( autoinsert )
)
read one (
    select user
    where user.email = ?
    where user.status != 0
)
read one (
    select user
    where user.id = ?
)
create user ( )
update user ( where user.id = ? )
delete user ( where user.id = ? )


model project (
    key id

    field id             blob

    field name           text
    field description    text      ( updatable )
    field usage_limit    int64     ( updatable )

    field created_at     timestamp ( autoinsert )
)
read all ( select project)
read one (
    select project
    where project.id = ?
)

read all (
    select project
    join project.id = project_member.project_id
    where project_member.member_id = ?
    orderby asc project.name
)
create project ( )
update project ( where project.id = ? )
delete project ( where project.id = ? )


model project_member (
    key member_id project_id

    field member_id            user.id      cascade
    field project_id           project.id   cascade

    field created_at           timestamp ( autoinsert )
)

read all (
    select project_member
    where project_member.member_id = ?
)
read limitoffset (
    select project_member
    where project_member.project_id = ?
)
create project_member ( )
delete project_member (
    where project_member.member_id = ?
    where project_member.project_id = ?
)

model api_key (
    key    id
    unique head
    unique name project_id

    field  id          blob
    field  project_id  project.id cascade
    field  head        blob
    field  name        text       (updatable)
    field  secret      blob
    field  created_at  timestamp  (autoinsert)
)

create api_key ()
update api_key ( where api_key.id = ? )
delete api_key ( where api_key.id = ? )

read one (
    select api_key
    where api_key.id = ?
)
read one (
    select api_key
    where api_key.head = ?
)
read all (
    select api_key
    where api_key.project_id = ?
    orderby asc api_key.name
)

//-----bucket_usage----//

model bucket_usage (
    key    id
    index (
    		name bucket_id_rollup
    		fields bucket_id rollup_end_time
    		unique
    	)

    field  id                 blob
    field  bucket_id          blob      //--TODO: add foreign key constraint--//

    field  rollup_end_time    timestamp

    field  remote_stored_data uint64
    field  inline_stored_data uint64
    field  remote_segments    uint
    field  inline_segments    uint
    field  objects            uint
    field  metadata_size      uint64
    field  repair_egress      uint64
    field  get_egress         uint64
    field  audit_egress       uint64
)

create bucket_usage ()
delete bucket_usage ( where bucket_usage.id = ? )

read one (
    select bucket_usage
    where  bucket_usage.id = ?
)

read limitoffset (
    select bucket_usage
    where bucket_usage.bucket_id = ?
    where bucket_usage.rollup_end_time > ?
    where bucket_usage.rollup_end_time <= ?
    orderby asc bucket_usage.rollup_end_time
)

read limitoffset (
    select bucket_usage
    where bucket_usage.bucket_id = ?
    where bucket_usage.rollup_end_time > ?
    where bucket_usage.rollup_end_time <= ?
    orderby desc bucket_usage.rollup_end_time
)

//--- tracking serial numbers ---//

model serial_number (
	key    id
	index (
	    name serial_number
	    fields serial_number
	    unique
	)

	field id            serial
	field serial_number blob

	field bucket_id     blob
	field expires_at    utimestamp

	index (
		fields expires_at
	)
)

model used_serial (
	key    serial_number_id storage_node_id

	field serial_number_id serial_number.id cascade
	field storage_node_id  blob
)

// inserting a new serial number
create serial_number ()

// finding out information about the serial number
read scalar (
	select serial_number
	where  serial_number.serial_number = ?
)

// deleting expired serial numbers
delete serial_number (
	where serial_number.expires_at <= ?
)

// for preventing duplicate serial numbers
create used_serial ()

// --- bucket accounting tables --- //

model bucket_bandwidth_rollup (
	key    bucket_name project_id interval_start action
	index (
	    name bucket_name_project_id_interval_start_interval_seconds
	    fields bucket_name project_id interval_start interval_seconds
	)

	field bucket_name       blob
	field project_id        blob

	field interval_start   utimestamp
	field interval_seconds uint
	field action           uint

	field inline    uint64 ( updatable )
	field allocated uint64 ( updatable )
	field settled   uint64 ( updatable )
)

read scalar (
	select bucket_bandwidth_rollup
	where  bucket_bandwidth_rollup.bucket_name = ?
	where  bucket_bandwidth_rollup.project_id = ?
	where  bucket_bandwidth_rollup.interval_start = ?
	where  bucket_bandwidth_rollup.action = ?
)

model bucket_storage_tally (
	key    bucket_name project_id interval_start

	field bucket_name       blob
	field project_id        blob

	field interval_start   utimestamp

	field inline uint64
	field remote uint64

	field  remote_segments_count    uint
	field  inline_segments_count    uint
	field  object_count             uint

	field  metadata_size      uint64
)

create bucket_storage_tally ()

read first (
    select bucket_storage_tally
    where bucket_storage_tally.project_id = ?
    orderby desc bucket_storage_tally.interval_start
)

read all (
    select bucket_storage_tally
    where bucket_storage_tally.project_id = ?
    where bucket_storage_tally.bucket_name = ?
    where bucket_storage_tally.interval_start >= ?
    where bucket_storage_tally.interval_start <= ?
    orderby desc bucket_storage_tally.interval_start
)

// --- storage node accounting tables --- //

model storagenode_bandwidth_rollup (
	key    storagenode_id interval_start action
	index (
	    name storagenode_id_interval_start_interval_seconds
	    fields storagenode_id interval_start interval_seconds
	)

	field storagenode_id   blob
	field interval_start   utimestamp
	field interval_seconds uint
	field action           uint

	field allocated uint64 ( updatable )
	field settled   uint64 ( updatable )
)

read scalar (
	select storagenode_bandwidth_rollup
	where  storagenode_bandwidth_rollup.storagenode_id = ?
	where  storagenode_bandwidth_rollup.interval_start = ?
	where  storagenode_bandwidth_rollup.action = ?
)

read all (
	select storagenode_bandwidth_rollup
	where storagenode_bandwidth_rollup.interval_start >= ?
)

model storagenode_storage_tally (
	key   id

	field id								serial64
	field node_id						blob
	field interval_end_time	timestamp
	field data_total				float64
)

create storagenode_storage_tally ()
delete storagenode_storage_tally ( where storagenode_storage_tally.id = ? )
read one (
		select storagenode_storage_tally
		where storagenode_storage_tally.id = ?
)
read all (
	select storagenode_storage_tally
)
read all (
	select storagenode_storage_tally
	where storagenode_storage_tally.interval_end_time >= ?
)

//--- certRecord ---//

model certRecord (
	key id

	field publickey  blob		//--uplink public key--//
	field id         blob		//--uplink node id  --//
	field update_at timestamp ( autoinsert, autoupdate )
)

create certRecord ( )
delete certRecord ( where certRecord.id = ? )
update certRecord ( where certRecord.id = ? )

read one (
	select certRecord
	where  certRecord.id = ?
)

//--- satellite registration token for Vanguard release (temporary table) ---//

model registration_token (
    key secret
    unique owner_id

    field secret        blob
    field owner_id      blob       ( updatable, nullable )

    field project_limit int

    field created_at    timestamp  ( autoinsert )
)

create registration_token ( )
read one (
    select registration_token
    where  registration_token.secret = ?
)
read one (
    select registration_token
    where  registration_token.owner_id = ?
)
update registration_token ( where registration_token.secret = ? )

//--- satellite reset password token ---//

model reset_password_token (
    key    secret
    unique owner_id

    field secret blob
    field owner_id blob        ( updatable )

    field created_at timestamp ( autoinsert )
)

create reset_password_token ( )
read one (
    select reset_password_token
    where reset_password_token.secret = ?
)
read one (
    select reset_password_token
    where reset_password_token.owner_id = ?
)
delete reset_password_token ( where reset_password_token.secret = ? )


//--- offer table ---//

model offer (
	key id
	
	field id	serial 
	field name text ( updatable )
	field description text ( updatable )

	// type has two possible value: FreeTier=1, Referral=2.
	field type int ( updatable )
	
	field credit_in_cents int ( updatable ) 
	field award_credit_duration_days int ( updatable )
	field invitee_credit_duration_days int ( updatable )

	field redeemable_cap int ( updatable )
	field num_redeemed int ( updatable, autoinsert )

	field expires_at timestamp ( updatable, autoinsert, nullable )
	field created_at timestamp ( autoinsert )

	// status has three possible value: NoStatus=0, OnGoing=1, Expired=2.
	field status int ( updatable, autoinsert )
)

read one (
    select offer
    where offer.id = ?
)

read one (
	select offer
	where offer.status = ?
	where offer.type = ?
	where offer.expires_at >= ?
)

read all ( select offer )

create offer ( )

update offer (
	where offer.id = ?
	where offer.status = 0
	where offer.expires_at >= offer.created_at
)

delete offer ( where offer.id = ? )