func TestParallel(t *testing.T) {
defer leaktest.AfterTest(t)()
if testutils.Stress() {
t.Skip()
}
glob := string(*paralleltestdata)
paths, err := filepath.Glob(glob)
if err != nil {
t.Fatal(err)
}
if len(paths) == 0 {
t.Fatalf("No testfiles found (glob: %s)", glob)
}
total := 0
for _, path := range paths {
t.Run(filepath.Base(path), func(t *testing.T) {
pt := parallelTest{T: t, ctx: context.Background()}
pt.run(path)
total++
})
}
log.Infof(context.Background(), "%d parallel tests passed", total)
}
func TestLogic(t *testing.T) {
defer leaktest.AfterTest(t)()
if testutils.Stress() {
t.Skip()
}
var globs []string
if *bigtest {
const logicTestPath = "../../sqllogictest"
if _, err := os.Stat(logicTestPath); os.IsNotExist(err) {
fullPath, err := filepath.Abs(logicTestPath)
if err != nil {
t.Fatal(err)
}
t.Fatalf("unable to find sqllogictest repo: %s\n"+
"git clone https://github.com/cockroachdb/sqllogictest %s",
logicTestPath, fullPath)
return
}
globs = []string{
logicTestPath + "/test/index/between/*/*.test",
logicTestPath + "/test/index/commute/*/*.test",
logicTestPath + "/test/index/delete/*/*.test",
logicTestPath + "/test/index/in/*/*.test",
logicTestPath + "/test/index/orderby/*/*.test",
logicTestPath + "/test/index/orderby_nosort/*/*.test",
// TODO(pmattis): We don't support aggregate functions.
// logicTestPath + "/test/random/expr/*.test",
// TODO(pmattis): We don't support tables without primary keys.
// logicTestPath + "/test/select*.test",
// TODO(pmattis): We don't support views.
// logicTestPath + "/test/index/view/*/*.test",
// TODO(pmattis): We don't support joins.
// [uses joins] logicTestPath + "/test/index/random/*/*.test",
// [uses joins] logicTestPath + "/test/random/aggregates/*.test",
// [uses joins] logicTestPath + "/test/random/groupby/*.test",
// [uses joins] logicTestPath + "/test/random/select/*.test",
}
} else {
globs = []string{*logictestdata}
}
var paths []string
for _, g := range globs {
match, err := filepath.Glob(g)
if err != nil {
t.Fatal(err)
}
paths = append(paths, match...)
}
if len(paths) == 0 {
t.Fatalf("No testfiles found (globs: %v)", globs)
}
total := 0
totalFail := 0
totalUnsupported := 0
lastProgress := timeutil.Now()
l := logicTest{
t: t,
verbose: testing.Verbose() || log.V(1),
perErrorSummary: make(map[string][]string),
}
if *printErrorSummary {
defer l.printErrorSummary()
}
for _, path := range paths {
t.Run(path, func(t *testing.T) {
// the `t` given to this anonymous function may be different
// from the t above, so re-bind it to `l` for the duration of
// the test.
l.t = t
defer l.close()
l.setup()
if err := l.processTestFile(path); err != nil {
t.Error(err)
}
})
total += l.progress
totalFail += l.failures
totalUnsupported += l.unsupported
now := timeutil.Now()
if now.Sub(lastProgress) >= 2*time.Second {
lastProgress = now
fmt.Printf("--- total progress: %d statements/queries\n", total)
}
}
unsupportedMsg := ""
if totalUnsupported > 0 {
unsupportedMsg = fmt.Sprintf(", ignored %d unsupported queries", totalUnsupported)
}
fmt.Printf("--- total: %d tests, %d failures%s\n", total, totalFail, unsupportedMsg)
}
func TestConcurrentBatch(t *testing.T) {
defer leaktest.AfterTest(t)()
if testutils.Stress() {
t.Skip()
}
dir, err := ioutil.TempDir("", "TestConcurrentBatch")
if err != nil {
t.Fatal(err)
}
defer func() {
if err := os.RemoveAll(dir); err != nil {
t.Fatal(err)
}
}()
db, err := NewRocksDB(roachpb.Attributes{}, dir, RocksDBCache{},
0, DefaultMaxOpenFiles)
if err != nil {
t.Fatalf("could not create new rocksdb db instance at %s: %v", dir, err)
}
defer db.Close()
// Prepare 16 4 MB batches containing non-overlapping contents.
var batches []Batch
for i := 0; i < 16; i++ {
batch := db.NewBatch()
for j := 0; true; j++ {
key := encoding.EncodeUvarintAscending([]byte("bar"), uint64(i))
key = encoding.EncodeUvarintAscending(key, uint64(j))
if err := batch.Put(MakeMVCCMetadataKey(key), nil); err != nil {
t.Fatal(err)
}
if len(batch.Repr()) >= 4<<20 {
break
}
}
batches = append(batches, batch)
}
errChan := make(chan error, len(batches))
// Concurrently write all the batches.
for _, batch := range batches {
go func(batch Batch) {
errChan <- batch.Commit()
}(batch)
}
// While the batch writes are in progress, try to write another key.
time.Sleep(100 * time.Millisecond)
remainingBatches := len(batches)
for i := 0; remainingBatches > 0; i++ {
select {
case err := <-errChan:
if err != nil {
t.Fatal(err)
}
remainingBatches--
default:
}
// This write can get delayed excessively if we hit the max memtable count
// or the L0 stop writes threshold.
start := timeutil.Now()
key := encoding.EncodeUvarintAscending([]byte("foo"), uint64(i))
if err := db.Put(MakeMVCCMetadataKey(key), nil); err != nil {
t.Fatal(err)
}
if elapsed := timeutil.Since(start); elapsed >= 10*time.Second {
t.Fatalf("write took %0.1fs\n", elapsed.Seconds())
}
}
}