Key Order in BoltDB

Which endian should be used for a boltdb's key? Should I get the endian of the machine first and use that?

I need the keys to be ordered properly - just as a sequence of bytes, no specific logic for ordering them. For example which endian should be used here (the Key is a sequential id, like a mongodb's one):

package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
    "log"
    "time"

    "github.com/boltdb/bolt"
)

var (
    Endian = binary.BigEndian // Which endian?
)

func main() {
    db, err := bolt.Open("temp.db", 0600, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    defer time.Sleep(time.Second)

    tempBucket := []byte("TMP")

    db.Update(func(tx *bolt.Tx) error {
        data := Row{
            Key: Key{
                Head:    0x1A1A1A,
                Mark:    0x1010,
                Counter: 0x01,
            },
            At:      time.Now().UTC().Unix(),
            Payload: 10,
        }

        keyBytes, err := marshal(&data.Key)
        if err != nil {
            return erp(err)
        }

        dataBytes, err := marshal(&data)
        if err != nil {
            return erp(err)
        }

        b, err := tx.CreateBucketIfNotExists(tempBucket)
        if err != nil {
            return erp(err)
        }

        err = b.Put(keyBytes, dataBytes)
        if err != nil {
            return erp(err)
        }

        return nil
    })

    db.View(func(tx *bolt.Tx) error {
        b := tx.Bucket(tempBucket)

        c := b.Cursor()

        for k, v := c.First(); k != nil; k, v = c.Next() {
            k, v := k, v
            fmt.Println(k, v)

            dt := Row{}
            err := unmarshal(&dt, v)
            if err != nil {
                return erp(err)
            }
            fmt.Printf("key=%X, value=%v\n", k, dt)
        }

        return nil
    })
}

func erp(e error) error {
    log.Println(e)
    return e
}

func marshal(pointerToData interface{}) ([]byte, error) {
    buf := new(bytes.Buffer)
    err := binary.Write(buf, Endian, pointerToData)
    if err != nil {
        return nil, err
    }
    return buf.Bytes(), nil
}

func unmarshal(pointerToData interface{}, bs []byte) error {
    buffer := bytes.NewBuffer(bs)
    err := binary.Read(buffer, Endian, pointerToData)
    if err != nil {
        return err
    }
    return nil
}

type Row struct {
    Key
    At      int64
    Payload int64
}

type Key struct {
    Head    uint32
    Mark    uint16
    Counter uint16
}

To have the keys naturally ordered, use BigEndian

In LittleEndian, the bytes are swapped, which would give it to you out of order.