func (is *kvis) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { log.Printf("Skipping storing (%q:%q): %v", key, value, err) return nil } return is.db.Set([]byte(key), []byte(value)) }
func (kv *keyValue) CommitBatch(bm sorted.BatchMutation) error { b, ok := bm.(batch) if !ok { return errors.New("invalid batch type") } kv.mu.Lock() defer kv.mu.Unlock() for _, m := range b.Mutations() { if m.IsDelete() { if err := kv.db.Remove(bson.M{mgoKey: m.Key()}); err != nil && err != mgo.ErrNotFound { return err } } else { if err := sorted.CheckSizes(m.Key(), m.Value()); err != nil { log.Printf("Skipping storing (%q:%q): %v", m.Key(), m.Value(), err) continue } if _, err := kv.db.Upsert(&bson.M{mgoKey: m.Key()}, &bson.M{mgoKey: m.Key(), mgoValue: m.Value()}); err != nil { return err } } } return nil }
func (kv *keyValue) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { return err } kv.mu.Lock() defer kv.mu.Unlock() _, err := kv.db.Upsert(&bson.M{mgoKey: key}, &bson.M{mgoKey: key, mgoValue: value}) return err }
func (kv *keyValue) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { log.Printf("Skipping storing (%q:%q): %v", key, value, err) return nil } kv.mu.Lock() defer kv.mu.Unlock() _, err := kv.db.Upsert(&bson.M{mgoKey: key}, &bson.M{mgoKey: key, mgoValue: value}) return err }
func (lvb *lvbatch) Set(key, value string) { lvb.errMu.Lock() defer lvb.errMu.Unlock() if lvb.err != nil { return } if err := sorted.CheckSizes(key, value); err != nil { log.Printf("Skipping storing (%q:%q): %v", key, value, err) return } lvb.batch.Put([]byte(key), []byte(value)) }
func (kv *KeyValue) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { return err } if kv.Serial { kv.mu.Lock() defer kv.mu.Unlock() } if kv.SetFunc != nil { return kv.SetFunc(kv.DB, key, value) } _, err := kv.DB.Exec(kv.sql("REPLACE INTO /*TPRE*/rows (k, v) VALUES (?, ?)"), key, value) return err }
func (b *batchTx) Set(key, value string) { if b.err != nil { return } if err := sorted.CheckSizes(key, value); err != nil { log.Printf("Skipping storing (%q:%q): %v", key, value, err) return } if b.kv.BatchSetFunc != nil { b.err = b.kv.BatchSetFunc(b.tx, key, value) return } _, b.err = b.tx.Exec(b.kv.sql("REPLACE INTO /*TPRE*/rows (k, v) VALUES (?, ?)"), key, value) }
func (kv *KeyValue) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { log.Printf("Skipping storing (%q:%q): %v", key, value, err) return nil } if kv.Gate != nil { kv.Gate.Start() defer kv.Gate.Done() } if kv.SetFunc != nil { return kv.SetFunc(kv.DB, key, value) } _, err := kv.DB.Exec(kv.sql("REPLACE INTO /*TPRE*/rows (k, v) VALUES (?, ?)"), key, value) return err }
func (lvb *lvbatch) Set(key, value string) { lvb.errMu.Lock() defer lvb.errMu.Unlock() if lvb.err != nil { return } if err := sorted.CheckSizes(key, value); err != nil { if err == sorted.ErrKeyTooLarge { lvb.err = fmt.Errorf("%v: %v", err, key) } else { lvb.err = fmt.Errorf("%v: %v", err, value) } return } lvb.batch.Put([]byte(key), []byte(value)) }
func (b *batchTx) Set(key, value string) { if b.err != nil { return } if err := sorted.CheckSizes(key, value); err != nil { if err == sorted.ErrKeyTooLarge { b.err = fmt.Errorf("%v: %v", err, key) } else { b.err = fmt.Errorf("%v: %v", err, value) } return } if b.kv.BatchSetFunc != nil { b.err = b.kv.BatchSetFunc(b.tx, key, value) return } _, b.err = b.tx.Exec(b.kv.sql("REPLACE INTO /*TPRE*/rows (k, v) VALUES (?, ?)"), key, value) }
func (kv *KeyValue) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { return err } kv.mu.RLock() err := kv.buf.Set(key, value) kv.mu.RUnlock() if err == nil { kv.bufMu.Lock() kv.buffered += int64(len(key) + len(value)) doFlush := kv.buffered > kv.maxBuffer kv.bufMu.Unlock() if doFlush { err = kv.Flush() } } return err }
func (kv *KeyValue) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { log.Printf("Skipping storing (%q:%q): %v", key, value, err) return nil } kv.mu.RLock() err := kv.buf.Set(key, value) kv.mu.RUnlock() if err == nil { kv.bufMu.Lock() kv.buffered += int64(len(key) + len(value)) doFlush := kv.buffered > kv.maxBuffer kv.bufMu.Unlock() if doFlush { err = kv.Flush() } } return err }
func (kv *KeyValue) CommitBatch(bm sorted.BatchMutation) error { kv.mu.RLock() defer kv.mu.RUnlock() b, ok := bm.(*batch) if !ok { return fmt.Errorf("unexpected BatchMutation type %T", bm) } var ( // A batch mutation for applying this mutation to the buffer. bmbuf = kv.buf.BeginBatch() // A lazily created batch mutation for deleting from the backing // storage; this should be rare. (See Delete above.) bmback sorted.BatchMutation ) for _, m := range b.mods { if m.isDelete { bmbuf.Delete(m.key) if bmback == nil { bmback = kv.back.BeginBatch() } bmback.Delete(m.key) continue } else { if err := sorted.CheckSizes(m.key, m.value); err != nil { log.Printf("Skipping storing (%q:%q): %v", m.key, m.value, err) continue } } bmbuf.Set(m.key, m.value) } if err := kv.buf.CommitBatch(bmbuf); err != nil { return err } if bmback != nil { return kv.back.CommitBatch(bmback) } return nil }
func (is *kvis) CommitBatch(bm sorted.BatchMutation) error { b, ok := bm.(batch) if !ok { return errors.New("invalid batch type") } is.txmu.Lock() defer is.txmu.Unlock() good := false defer func() { if !good { is.db.Rollback() } }() if err := is.db.BeginTransaction(); err != nil { return err } for _, m := range b.Mutations() { if m.IsDelete() { if err := is.db.Delete([]byte(m.Key())); err != nil { return err } } else { if err := sorted.CheckSizes(m.Key(), m.Value()); err != nil { log.Printf("Skipping storing (%q:%q): %v", m.Key(), m.Value(), err) continue } if err := is.db.Set([]byte(m.Key()), []byte(m.Value())); err != nil { return err } } } good = true return is.db.Commit() }
func (kv *keyValue) CommitBatch(bm sorted.BatchMutation) error { b, ok := bm.(batch) if !ok { return errors.New("invalid batch type") } kv.mu.Lock() defer kv.mu.Unlock() for _, m := range b.Mutations() { if m.IsDelete() { if err := kv.db.Remove(bson.M{mgoKey: m.Key()}); err != nil { return err } } else { if err := sorted.CheckSizes(m.Key(), m.Value()); err != nil { return err } if _, err := kv.db.Upsert(&bson.M{mgoKey: m.Key()}, &bson.M{mgoKey: m.Key(), mgoValue: m.Value()}); err != nil { return err } } } return nil }
func (is *kvis) Set(key, value string) error { if err := sorted.CheckSizes(key, value); err != nil { return err } return is.db.Put([]byte(key), []byte(value), is.writeOpts) }