// Delete using a Where Expression
func (m *dbConn) DeleteExpression(where expr.Node) (int, error) {
//return 0, fmt.Errorf("not implemented")
evaluator := vm.Evaluator(where)
var deletedKeys []schema.Key
txn := m.db.Txn(true)
iter, err := txn.Get(m.md.tbl.Name, m.md.primaryIndex)
if err != nil {
txn.Abort()
u.Errorf("could not get values %v", err)
return 0, err
}
deleteLoop:
for {
item := iter.Next()
if item == nil {
break
}
msg, ok := item.(datasource.SqlDriverMessage)
if !ok {
u.Warnf("wat? %T %#v", item, item)
err = fmt.Errorf("unexpected message type %T", item)
break
}
whereValue, ok := evaluator(msg.ToMsgMap(m.md.tbl.FieldPositions))
if !ok {
u.Debugf("could not evaluate where: %v", msg)
}
switch whereVal := whereValue.(type) {
case value.BoolValue:
if whereVal.Val() == false {
//this means do NOT delete
} else {
// Delete!
if err = txn.Delete(m.md.tbl.Name, msg); err != nil {
u.Errorf("could not delete %v", err)
break deleteLoop
}
indexVal := msg.Vals[0]
deletedKeys = append(deletedKeys, schema.NewKeyUint(makeId(indexVal)))
}
case nil:
// ??
u.Warnf("this should be fine, couldn't evaluate so don't delete %v", msg)
default:
if whereVal.Nil() {
// Doesn't match, so don't delete
} else {
u.Warnf("unknown where eval result? %T", whereVal)
}
}
}
if err != nil {
txn.Abort()
return 0, err
}
txn.Commit()
return len(deletedKeys), nil
}
func (m *dbConn) putValues(txn *memdb.Txn, row []driver.Value) (schema.Key, error) {
if len(row) != len(m.Columns()) {
u.Warnf("wrong column ct expected %d got %d for %v", len(m.Columns()), len(row), row)
return nil, fmt.Errorf("Wrong number of columns, expected %v got %v", len(m.Columns()), len(row))
}
id := makeId(row[0])
msg := &datasource.SqlDriverMessage{Vals: row, IdVal: id}
txn.Insert(m.md.tbl.Name, msg)
//u.Debugf("%p PUT: id:%v IdVal:%v Id():%v vals:%#v", m, id, sdm.IdVal, sdm.Id(), rowVals)
return schema.NewKeyUint(id), nil
}
