Esempio n. 1
0
// Begin transaction
func (s *dbStore) Begin() (kv.Transaction, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	beginVer, err := globalVersionProvider.CurrentVersion()
	if err != nil {
		return nil, err
	}
	txn := &dbTxn{
		tid:          beginVer.Ver,
		valid:        true,
		store:        s,
		version:      kv.MinVersion,
		snapshotVals: make(map[string][]byte),
	}
	log.Debugf("Begin txn:%d", txn.tid)
	txn.UnionStore, err = kv.NewUnionStore(&dbSnapshot{
		db:      s.db,
		version: beginVer,
	})
	if err != nil {
		return nil, errors.Trace(err)
	}
	return txn, nil
}
Esempio n. 2
0
File: kv.go Progetto: yzl11/vessel
// Begin transaction
func (s *dbStore) Begin() (kv.Transaction, error) {
	providerMu.RLock()
	beginVer, err := globalVersionProvider.CurrentVersion()
	providerMu.RUnlock()
	if err != nil {
		return nil, errors.Trace(err)
	}

	s.mu.RLock()
	closed := s.closed
	s.mu.RUnlock()
	if closed {
		return nil, errors.Trace(ErrDBClosed)
	}

	txn := &dbTxn{
		tid:          beginVer.Ver,
		valid:        true,
		store:        s,
		version:      kv.MinVersion,
		snapshotVals: make(map[string]struct{}),
		opts:         make(map[kv.Option]interface{}),
	}
	log.Debugf("Begin txn:%d", txn.tid)
	txn.UnionStore = kv.NewUnionStore(newSnapshot(s, s.db, beginVer), options(txn.opts))
	return txn, nil
}
Esempio n. 3
0
File: txn.go Progetto: astaxie/tidb
func newHbaseTxn(t themis.Txn, storeName string) *hbaseTxn {
	return &hbaseTxn{
		txn:       t,
		valid:     true,
		storeName: storeName,
		tid:       t.GetStartTS(),
		us:        kv.NewUnionStore(newHbaseSnapshot(t, storeName)),
	}
}
Esempio n. 4
0
File: kv.go Progetto: xwb1989/tidb
func (s *hbaseStore) Begin() (kv.Transaction, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	hbaseCli := s.getHBaseClient()
	t := themis.NewTxn(hbaseCli)
	txn := newHbaseTxn(t, s.storeName)
	txn.UnionStore = kv.NewUnionStore(newHbaseSnapshot(t, s.storeName))
	return txn, nil
}
Esempio n. 5
0
File: txn.go Progetto: BobbWu/tidb
func newHbaseTxn(t *themis.Txn, storeName string) *hbaseTxn {
	opts := make(map[kv.Option]interface{})
	return &hbaseTxn{
		Txn:        t,
		valid:      true,
		storeName:  storeName,
		tid:        t.GetStartTS(),
		UnionStore: kv.NewUnionStore(newHbaseSnapshot(t, storeName), options(opts)),
		opts:       opts,
	}
}
Esempio n. 6
0
File: txn.go Progetto: lovedboy/tidb
func newTxn(s *dbStore, ver kv.Version) *dbTxn {
	txn := &dbTxn{
		us:         kv.NewUnionStore(newSnapshot(s, ver)),
		store:      s,
		tid:        ver.Ver,
		valid:      true,
		version:    kv.MinVersion,
		lockedKeys: make(map[string]struct{}),
	}
	log.Debugf("[kv] Begin txn:%d", txn.tid)
	return txn
}
Esempio n. 7
0
File: txn.go Progetto: anywhy/tidb
func newTiKVTxn(store *tikvStore) (*tikvTxn, error) {
	startTS, err := store.getTimestampWithRetry()
	if err != nil {
		return nil, errors.Trace(err)
	}
	ver := kv.NewVersion(startTS)
	return &tikvTxn{
		us:      kv.NewUnionStore(newTiKVSnapshot(store, ver)),
		store:   store,
		startTS: startTS,
		valid:   true,
	}, nil
}
Esempio n. 8
0
File: txn.go Progetto: pingcap/tidb
func newTiKVTxn(store *tikvStore) (*tikvTxn, error) {
	bo := NewBackoffer(tsoMaxBackoff, context.Background())
	startTS, err := store.getTimestampWithRetry(bo)
	if err != nil {
		return nil, errors.Trace(err)
	}
	ver := kv.NewVersion(startTS)
	return &tikvTxn{
		us:      kv.NewUnionStore(newTiKVSnapshot(store, ver)),
		store:   store,
		startTS: startTS,
		valid:   true,
	}, nil
}
Esempio n. 9
0
File: kv.go Progetto: ninefive/tidb
// Begin transaction
func (s *dbStore) Begin() (kv.Transaction, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	snapshot, err := s.db.GetSnapshot()
	if err != nil {
		return nil, err
	}

	txn := &dbTxn{
		startTs:      time.Now(),
		tID:          atomic.AddInt64(&globalID, 1),
		valid:        true,
		store:        s,
		snapshotVals: make(map[string][]byte),
	}
	log.Debugf("Begin txn:%d", txn.tID)
	txn.UnionStore, err = kv.NewUnionStore(&dbSnapshot{snapshot})
	if err != nil {
		return nil, err
	}
	return txn, nil
}