all repos — min @ 27f077568b869ff08a70e27e1ad5b7f6f093866d

A small but practical concatenative programming language.

lib/min_dstore.nim

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 
import
  json,
  strutils,
  oids
import
  ../core/parser,
  ../core/value,
  ../core/interpreter,
  ../core/utils

proc dstore_module*(i: In)=
  let def = i.define()

  def.symbol("dsinit") do (i: In):
    let vals = i.expect("'sym")
    let p = vals[0].getString
    var j = %*{"collections": {}}
    p.writeFile(j.pretty)
    var d = newDict(i.scope)
    i.dset(d, "data", i.fromJson(j))
    i.dset(d, "path", p.newVal)
    d.objType = "datastore"
    i.push d 
 
  def.symbol("dsread") do (i: In):
    let vals = i.expect("'sym")
    let p = vals[0].getString
    var j = p.readFile.parseJson 
    var d = newDict(i.scope)
    i.dset(d, "data", i.fromJson(j))
    i.dset(d, "path", p.newVal)
    d.objType = "datastore"
    i.push d 
  
  def.symbol("dswrite") do (i: In):
    let vals = i.expect("dict:datastore")
    let ds = vals[0]
    let p = i.dget(ds, "path".newVal).getString
    let data = i%(i.dget(ds, "data".newVal))
    p.writeFile(data.pretty)
    
  def.symbol("dshas?") do (i: In):
    let vals = i.expect("'sym", "dict:datastore")
    let s = vals[0].getString
    let ds = vals[1]
    let parts = s.split("/")
    let collection = parts[0]
    let id = parts[1]
    let data = i.dget(ds, "data".newVal)
    let cll = i.dget(data, collection.newVal)
    if dhas(cll, id.newVal):
      i.push true.newVal
    else:
      i.push false.newVal
      
  def.symbol("dsget") do (i: In):
    let vals = i.expect("'sym", "dict:datastore")
    let s = vals[0].getString
    let ds = vals[1]
    let parts = s.split("/")
    let collection = parts[0]
    let id = parts[1]
    let data = i.dget(ds, "data".newVal)
    let cll = i.dget(data, collection)
    i.push i.dget(cll, id.newVal)
    
  def.symbol("dsquery") do (i: In):
    let vals = i.expect("quot", "'sym",  "dict:datastore")
    var filter = vals[0]
    let collection = vals[1]
    let ds = vals[2]
    let data = i.dget(ds, "data".newVal)
    let cll = i.dget(data, collection)
    var res = newSeq[MinValue](0)
    for e in i.values(cll).qVal:
      i.push e
      i.dequote(filter)
      var check = i.pop
      if check.isBool and check.boolVal == true:
        res.add e
    i.push res.newVal
      
  def.symbol("dspost") do (i: In):
    let vals = i.expect("dict", "'sym", "dict:datastore")
    var d = vals[0]
    let collection = vals[1]
    var ds = vals[2]
    let id = $genOid()
    i.dset(d, "id", id.newVal)
    var data = i.dget(ds, "data".newVal)
    if not dhas(data, collection):
      i.dset(data, collection, newDict(i.scope))
    var cll = i.dget(data, collection)
    i.dset(cll, id, d)
    #i.dset(ds, "data", data)
    i.push ds
    
  def.symbol("dsput") do (i: In):
    let vals = i.expect("dict", "'sym", "dict:datastore")
    var d = vals[0]
    let s = vals[1].getString
    let ds = vals[2]
    let parts = s.split("/")
    let collection = parts[0]
    let id = parts[1]
    var data = i.dget(ds, "data".newVal)
    var cll = i.dget(data, collection)
    i.dset(cll, id, d)
    #i.dset(ds, "data", data)
    i.push ds
    
  def.symbol("dsdelete") do (i: In):
    let vals = i.expect("'sym", "dict:datastore")
    let s = vals[0].getString
    let ds = vals[1]
    let parts = s.split("/")
    let collection = parts[0]
    let id = parts[1]
    var data = i.dget(ds, "data".newVal)
    var cll = i.dget(data, collection)
    i.ddel(cll, id) 
    i.push ds
    
  def.finalize("dstore")