// 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 }