func TestConsolidation(t *testing.T) {
vstart := framework.DebugVars()
defer framework.DefaultServer.SetPoolSize(framework.DefaultServer.PoolSize())
framework.DefaultServer.SetPoolSize(1)
var wg sync.WaitGroup
wg.Add(2)
go func() {
framework.NewDefaultClient().Execute("select sleep(0.25) from dual", nil)
wg.Done()
}()
go func() {
framework.NewDefaultClient().Execute("select sleep(0.25) from dual", nil)
wg.Done()
}()
wg.Wait()
vend := framework.DebugVars()
if err := compareIntDiff(vend, "Waits/TotalCount", vstart, 1); err != nil {
t.Error(err)
}
if err := compareIntDiff(vend, "Waits/Histograms/Consolidations/Count", vstart, 1); err != nil {
t.Error(err)
}
}
func TestPoolSize(t *testing.T) {
vstart := framework.DebugVars()
defer framework.DefaultServer.SetPoolSize(framework.DefaultServer.PoolSize())
framework.DefaultServer.SetPoolSize(1)
var wg sync.WaitGroup
wg.Add(2)
go func() {
framework.NewDefaultClient().Execute("select sleep(0.25) from dual", nil)
wg.Done()
}()
// The queries have to be different so consolidator doesn't kick in.
go func() {
framework.NewDefaultClient().Execute("select sleep(0.24) from dual", nil)
wg.Done()
}()
wg.Wait()
vend := framework.DebugVars()
if err := verifyIntValue(vend, "ConnPoolCapacity", 1); err != nil {
t.Error(err)
}
if err := compareIntDiff(vend, "ConnPoolWaitCount", vstart, 1); err != nil {
t.Error(err)
}
}
func TestStrictMode(t *testing.T) {
queries := []string{
"insert into vtocc_a(eid, id, name, foo) values (7, 1+1, '', '')",
"insert into vtocc_d(eid, id) values (1, 1)",
"update vtocc_a set eid = 1+1 where eid = 1 and id = 1",
"insert into vtocc_d(eid, id) values (1, 1)",
"insert into upsert_test(id1, id2) values " +
"(1, 1), (2, 2) on duplicate key update id1 = 1",
"insert into upsert_test(id1, id2) select eid, id " +
"from vtocc_a limit 1 on duplicate key update id2 = id1",
"insert into upsert_test(id1, id2) values " +
"(1, 1) on duplicate key update id1 = 2+1",
}
// Strict mode on.
func() {
client := framework.NewDefaultClient()
err := client.Begin()
if err != nil {
t.Error(err)
return
}
defer client.Rollback()
want := "error: DML too complex"
for _, query := range queries {
_, err = client.Execute(query, nil)
if err == nil || err.Error() != want {
t.Errorf("Execute(%s): %v, want %s", query, err, want)
}
}
}()
// Strict mode off.
func() {
framework.DefaultServer.SetStrictMode(false)
defer framework.DefaultServer.SetStrictMode(true)
for _, query := range queries {
client := framework.NewDefaultClient()
err := client.Begin()
if err != nil {
t.Error(err)
return
}
_, err = client.Execute(query, nil)
if err != nil {
t.Error(err)
}
client.Rollback()
}
}()
}
func TestSchemaReload(t *testing.T) {
conn, err := mysql.Connect(connParams)
if err != nil {
t.Error(err)
return
}
_, err = conn.ExecuteFetch("create table vtocc_temp(intval int)", 10, false)
if err != nil {
t.Error(err)
return
}
defer func() {
_, _ = conn.ExecuteFetch("drop table vtocc_temp", 10, false)
conn.Close()
}()
framework.DefaultServer.ReloadSchema()
client := framework.NewDefaultClient()
waitTime := 50 * time.Millisecond
for i := 0; i < 10; i++ {
time.Sleep(waitTime)
waitTime += 50 * time.Millisecond
_, err = client.Execute("select * from vtocc_temp", nil)
if err == nil {
return
}
want := "error: table vtocc_temp not found in schema"
if err.Error() != want {
t.Errorf("Error: %v, want %s", err, want)
return
}
}
t.Error("schema did not reload")
}
func TestCacheListArgs(t *testing.T) {
client := framework.NewDefaultClient()
query := "select * from vtocc_cached1 where eid in ::list"
successCases := []struct {
bv map[string]interface{}
rowcount uint64
}{{
bv: map[string]interface{}{"list": []interface{}{3, 4, 32768}},
rowcount: 2,
}, {
bv: map[string]interface{}{"list": []interface{}{3, 4}},
rowcount: 2,
}, {
bv: map[string]interface{}{"list": []interface{}{3}},
rowcount: 1,
}}
for _, success := range successCases {
qr, err := client.Execute(query, success.bv)
if err != nil {
t.Error(err)
continue
}
if qr.RowsAffected != success.rowcount {
t.Errorf("RowsAffected: %d, want %d", qr.RowsAffected, success.rowcount)
}
}
_, err := client.Execute(query, map[string]interface{}{"list": []interface{}{}})
want := "error: empty list supplied"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, want %s", err, want)
return
}
}
func TestNull(t *testing.T) {
client := framework.NewDefaultClient()
qr, err := client.Execute("select null from dual", nil)
if err != nil {
t.Error(err)
return
}
want := mproto.QueryResult{
Fields: []mproto.Field{
{
Name: "NULL",
Type: mysql.TypeNull,
Flags: mysql.FlagBinary,
},
},
RowsAffected: 1,
Rows: [][]sqltypes.Value{
[]sqltypes.Value{
sqltypes.Value{},
},
},
}
if !reflect.DeepEqual(*qr, want) {
t.Errorf("Execute: \n%#v, want \n%#v", *qr, want)
}
}
func TestQueryTimeout(t *testing.T) {
vstart := framework.DebugVars()
defer framework.DefaultServer.QueryTimeout.Set(framework.DefaultServer.QueryTimeout.Get())
framework.DefaultServer.QueryTimeout.Set(10 * time.Millisecond)
client := framework.NewDefaultClient()
err := client.Begin()
if err != nil {
t.Error(err)
return
}
_, err = client.Execute("select sleep(0.5) from vtocc_test", nil)
want := "error: the query was killed"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, must start with %s", err, want)
}
_, err = client.Execute("select 1 from dual", nil)
want = "not_in_tx: Transaction"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, must start with %s", err, want)
}
vend := framework.DebugVars()
if err := verifyIntValue(vend, "QueryTimeout", int(10*time.Millisecond)); err != nil {
t.Error(err)
}
if err := compareIntDiff(vend, "Kills/Queries", vstart, 1); err != nil {
t.Error(err)
}
}
func TestDBAStatements(t *testing.T) {
client := framework.NewDefaultClient()
qr, err := client.Execute("show variables like 'version'", nil)
if err != nil {
t.Error(err)
return
}
wantCol := sqltypes.Value{Inner: sqltypes.String("version")}
if !reflect.DeepEqual(qr.Rows[0][0], wantCol) {
t.Errorf("Execute: \n%#v, want \n%#v", qr.Rows[0][0], wantCol)
}
qr, err = client.Execute("describe vtocc_a", nil)
if err != nil {
t.Error(err)
return
}
if qr.RowsAffected != 4 {
t.Errorf("RowsAffected: %d, want 4", qr.RowsAffected)
}
qr, err = client.Execute("explain vtocc_a", nil)
if err != nil {
t.Error(err)
return
}
if qr.RowsAffected != 4 {
t.Errorf("RowsAffected: %d, want 4", qr.RowsAffected)
}
}
func TestCacheStats(t *testing.T) {
client := framework.NewDefaultClient()
query := "select * from vtocc_cached2 where eid = 2 and bid = 'foo'"
_, err := client.Execute(query, nil)
if err != nil {
t.Error(err)
return
}
vstart := framework.DebugVars()
_, err = client.Execute(query, nil)
if err != nil {
t.Error(err)
return
}
if err := compareIntDiff(framework.DebugVars(), "RowcacheStats/vtocc_cached2.Hits", vstart, 1); err != nil {
t.Error(err)
}
vstart = framework.DebugVars()
_, err = client.Execute("update vtocc_part2 set data2 = 2 where key3 = 1", nil)
if err != nil {
t.Error(err)
return
}
_, err = client.Execute("select * from vtocc_view where key2 = 1", nil)
if err != nil {
t.Error(err)
return
}
if err := compareIntDiff(framework.DebugVars(), "RowcacheStats/vtocc_view.Misses", vstart, 1); err != nil {
t.Error(err)
}
}
func TestCacheTypes(t *testing.T) {
client := framework.NewDefaultClient()
badRequests := []struct {
query string
bv map[string]interface{}
}{{
query: "select * from vtocc_cached2 where eid = 'str' and bid = 'str'",
}, {
query: "select * from vtocc_cached2 where eid = :str and bid = :str",
bv: map[string]interface{}{"str": "str"},
}, {
query: "select * from vtocc_cached2 where eid = 1 and bid = 1",
}, {
query: "select * from vtocc_cached2 where eid = :id and bid = :id",
bv: map[string]interface{}{"id": 1},
}, {
query: "select * from vtocc_cached2 where eid = 1.2 and bid = 1.2",
}, {
query: "select * from vtocc_cached2 where eid = :fl and bid = :fl",
bv: map[string]interface{}{"fl": 1.2},
}}
want := "error: type mismatch"
for _, request := range badRequests {
_, err := client.Execute(request.query, request.bv)
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, want %s", err, want)
}
}
}
func TestTxTimeout(t *testing.T) {
vstart := framework.DebugVars()
defer framework.DefaultServer.SetTxTimeout(framework.DefaultServer.TxTimeout())
framework.DefaultServer.SetTxTimeout(1 * time.Millisecond)
if err := verifyIntValue(framework.DebugVars(), "TransactionPoolTimeout", int(1*time.Millisecond)); err != nil {
t.Error(err)
}
catcher := framework.NewTxCatcher()
defer catcher.Close()
client := framework.NewDefaultClient()
err := client.Begin()
if err != nil {
t.Error(err)
return
}
time.Sleep(5 * time.Millisecond)
err = client.Commit()
want := "not_in_tx: Transaction"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, must contain %s", err, want)
}
tx, err := catcher.Next()
if err != nil {
t.Error(err)
return
}
if tx.Conclusion != "kill" {
t.Errorf("Conclusion: %s, want kill", tx.Conclusion)
}
if err := compareIntDiff(framework.DebugVars(), "Kills/Transactions", vstart, 1); err != nil {
t.Error(err)
}
}
func TestForUpdate(t *testing.T) {
for _, mode := range []string{"for update", "lock in share mode"} {
client := framework.NewDefaultClient()
query := fmt.Sprintf("select * from vtocc_test where intval=2 %s", mode)
_, err := client.Execute(query, nil)
want := "error: Disallowed"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, must have prefix %s", err, want)
}
// We should not get errors here
err = client.Begin()
if err != nil {
t.Error(err)
return
}
_, err = client.Execute(query, nil)
if err != nil {
t.Error(err)
return
}
err = client.Commit()
if err != nil {
t.Error(err)
return
}
}
}
func TestUncacheableTables(t *testing.T) {
client := framework.NewDefaultClient()
nocacheTables := []struct {
name string
create string
drop string
}{{
create: "create table vtocc_nocache(eid int, primary key (eid)) comment 'vtocc_nocache'",
drop: "drop table vtocc_nocache",
}, {
create: "create table vtocc_nocache(somecol int)",
drop: "drop table vtocc_nocache",
}, {
create: "create table vtocc_nocache(charcol varchar(10), primary key(charcol))",
drop: "drop table vtocc_nocache",
}}
for _, tcase := range nocacheTables {
_, err := client.Execute(tcase.create, nil)
if err != nil {
t.Error(err)
return
}
table, ok := framework.DebugSchema()["vtocc_nocache"]
client.Execute(tcase.drop, nil)
if !ok {
t.Errorf("%s: table vtocc_nocache not found in schema", tcase.create)
continue
}
if table.CacheType != schema.CACHE_NONE {
t.Errorf("CacheType: %d, want %d", table.CacheType, schema.CACHE_NONE)
}
}
}
func TestUncache(t *testing.T) {
// Verify rowcache is working vtocc_cached2
err := verifyVtoccCached2(t, "vtocc_cached2")
if err != nil {
t.Error(err)
return
}
// Disable rowcache for vtocc_cached2
client := framework.NewDefaultClient()
_, err = client.Execute("alter table vtocc_cached2 comment 'vtocc_nocache'", nil)
if err != nil {
t.Error(err)
return
}
_, err = client.Execute("select * from vtocc_cached2 where eid = 2 and bid = 'foo'", nil)
if err != nil {
t.Error(err)
}
if tstat, ok := framework.TableStats()["vtocc_cached2"]; ok {
t.Errorf("table stats was found: %v, want not found", tstat)
}
// Re-enable rowcache and verify it's working
_, err = client.Execute("alter table vtocc_cached2 comment ''", nil)
if err != nil {
t.Error(err)
return
}
err = verifyVtoccCached2(t, "vtocc_cached2")
if err != nil {
t.Error(err)
return
}
}
func TestNocacheListArgs(t *testing.T) {
client := framework.NewDefaultClient()
query := "select * from vtocc_test where intval in ::list"
qr, err := client.Execute(
query,
map[string]interface{}{
"list": []interface{}{2, 3, 4},
},
)
if err != nil {
t.Error(err)
return
}
if qr.RowsAffected != 2 {
t.Errorf("rows affected: %d, want 2", qr.RowsAffected)
}
qr, err = client.Execute(
query,
map[string]interface{}{
"list": []interface{}{3, 4},
},
)
if err != nil {
t.Error(err)
return
}
if qr.RowsAffected != 1 {
t.Errorf("rows affected: %d, want 1", qr.RowsAffected)
}
qr, err = client.Execute(
query,
map[string]interface{}{
"list": []interface{}{3},
},
)
if err != nil {
t.Error(err)
return
}
if qr.RowsAffected != 1 {
t.Errorf("rows affected: %d, want 1", qr.RowsAffected)
}
// Error case
_, err = client.Execute(
query,
map[string]interface{}{
"list": []interface{}{},
},
)
want := "error: empty list supplied for list"
if err == nil || err.Error() != want {
t.Errorf("Error: %v, want %s", err, want)
return
}
}
func TestBinary(t *testing.T) {
client := framework.NewDefaultClient()
defer client.Execute("delete from vtocc_test where intval in (4,5)", nil)
binaryData := "\x00'\"\b\n\r\t\x1a\\\x00\x0f\xf0\xff"
// Test without bindvars.
_, err := client.Execute(
"insert into vtocc_test values "+
"(4, null, null, '\\0\\'\\\"\\b\\n\\r\\t\\Z\\\\\x00\x0f\xf0\xff')",
nil,
)
if err != nil {
t.Error(err)
return
}
qr, err := client.Execute("select binval from vtocc_test where intval=4", nil)
if err != nil {
t.Error(err)
return
}
want := mproto.QueryResult{
Fields: []mproto.Field{
{
Name: "binval",
Type: mysql.TypeVarString,
Flags: mysql.FlagBinary,
},
},
RowsAffected: 1,
Rows: [][]sqltypes.Value{
[]sqltypes.Value{
sqltypes.Value{Inner: sqltypes.String(binaryData)},
},
},
}
if !reflect.DeepEqual(*qr, want) {
t.Errorf("Execute: \n%#v, want \n%#v", *qr, want)
}
// Test with bindvars.
_, err = client.Execute(
"insert into vtocc_test values(5, null, null, :bindata)",
map[string]interface{}{"bindata": binaryData},
)
if err != nil {
t.Error(err)
return
}
qr, err = client.Execute("select binval from vtocc_test where intval=5", nil)
if err != nil {
t.Error(err)
return
}
if !reflect.DeepEqual(*qr, want) {
t.Errorf("Execute: \n%#v, want \n%#v", *qr, want)
}
}
func TestNoData(t *testing.T) {
qr, err := framework.NewDefaultClient().Execute("select * from vtocc_cached2 where eid = 6 and name = 'bar'", nil)
if err != nil {
t.Error(err)
return
}
if qr.RowsAffected != 0 {
t.Errorf("RowsAffected: %d, want 0", qr.RowsAffected)
}
}
func TestAutoCommitOff(t *testing.T) {
framework.DefaultServer.SetAutoCommit(false)
defer framework.DefaultServer.SetAutoCommit(true)
_, err := framework.NewDefaultClient().Execute("insert into vtocc_test values(4, null, null, null)", nil)
want := "error: unsupported query"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, must start with %s", err, want)
}
}
func TestIntegrityError(t *testing.T) {
vstart := framework.DebugVars()
client := framework.NewDefaultClient()
_, err := client.Execute("insert into vtocc_test values(1, null, null, null)", nil)
want := "error: Duplicate entry '1'"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, want prefix %s", err, want)
}
if err := compareIntDiff(framework.DebugVars(), "InfoErrors/DupKey", vstart, 1); err != nil {
t.Error(err)
}
}
func TestTxPoolSize(t *testing.T) {
vstart := framework.DebugVars()
client1 := framework.NewDefaultClient()
err := client1.Begin()
if err != nil {
t.Error(err)
return
}
defer client1.Rollback()
if err := verifyIntValue(framework.DebugVars(), "TransactionPoolAvailable", framework.BaseConfig.TransactionCap-1); err != nil {
t.Error(err)
}
defer framework.DefaultServer.SetTxPoolSize(framework.DefaultServer.TxPoolSize())
framework.DefaultServer.SetTxPoolSize(1)
defer framework.DefaultServer.BeginTimeout.Set(framework.DefaultServer.BeginTimeout.Get())
timeout := 1 * time.Millisecond
framework.DefaultServer.BeginTimeout.Set(timeout)
vend := framework.DebugVars()
if err := verifyIntValue(vend, "TransactionPoolAvailable", 0); err != nil {
t.Error(err)
}
if err := verifyIntValue(vend, "TransactionPoolCapacity", 1); err != nil {
t.Error(err)
}
if err := verifyIntValue(vend, "BeginTimeout", int(timeout)); err != nil {
t.Error(err)
}
client2 := framework.NewDefaultClient()
err = client2.Begin()
want := "tx_pool_full"
if err == nil || !strings.Contains(err.Error(), want) {
t.Errorf("Error: %v, must contain %s", err, want)
}
if err := compareIntDiff(framework.DebugVars(), "Errors/TxPoolFull", vstart, 1); err != nil {
t.Error(err)
}
}
func TestQueryStats(t *testing.T) {
client := framework.NewDefaultClient()
vstart := framework.DebugVars()
start := time.Now()
query := "select /* query_stats */ eid from vtocc_a where eid = :eid"
bv := map[string]interface{}{"eid": 1}
_, _ = client.Execute(query, bv)
stat := framework.QueryStats()[query]
duration := int(time.Now().Sub(start))
if stat.Time <= 0 || stat.Time > duration {
t.Errorf("stat.Time: %d, must be between 0 and %d", stat.Time, duration)
}
stat.Time = 0
want := framework.QueryStat{
Query: query,
Table: "vtocc_a",
Plan: "PASS_SELECT",
QueryCount: 1,
RowCount: 2,
ErrorCount: 0,
}
if stat != want {
t.Errorf("stat: %+v, want %+v", stat, want)
}
query = "select /* query_stats */ eid from vtocc_a where dontexist(eid) = :eid"
_, _ = client.Execute(query, bv)
stat = framework.QueryStats()[query]
stat.Time = 0
want = framework.QueryStat{
Query: query,
Table: "vtocc_a",
Plan: "PASS_SELECT",
QueryCount: 1,
RowCount: 0,
ErrorCount: 1,
}
if stat != want {
t.Errorf("stat: %+v, want %+v", stat, want)
}
vend := framework.DebugVars()
if err := compareIntDiff(vend, "QueryCounts/vtocc_a.PASS_SELECT", vstart, 2); err != nil {
t.Error(err)
}
if err := compareIntDiff(vend, "QueryRowCounts/vtocc_a.PASS_SELECT", vstart, 2); err != nil {
t.Error(err)
}
if err := compareIntDiff(vend, "QueryErrorCounts/vtocc_a.PASS_SELECT", vstart, 1); err != nil {
t.Error(err)
}
}
func TestSimpleRead(t *testing.T) {
vstart := framework.DebugVars()
_, err := framework.NewDefaultClient().Execute("select * from vtocc_test where intval=1", nil)
if err != nil {
t.Error(err)
return
}
vend := framework.DebugVars()
if err := compareIntDiff(vend, "Queries/TotalCount", vstart, 1); err != nil {
t.Error(err)
}
if err := compareIntDiff(vend, "Queries/Histograms/PASS_SELECT/Count", vstart, 1); err != nil {
t.Error(err)
}
}
func TestSpotCheck(t *testing.T) {
vstart := framework.DebugVars()
client := framework.NewDefaultClient()
_, err := client.Execute("select * from vtocc_cached2 where eid = 2 and bid = 'foo'", nil)
if err != nil {
t.Error(err)
return
}
if err := compareIntDiff(framework.DebugVars(), "RowcacheSpotCheckCount", vstart, 0); err != nil {
t.Error(err)
}
defer framework.DefaultServer.SetSpotCheckRatio(framework.DefaultServer.SpotCheckRatio())
framework.DefaultServer.SetSpotCheckRatio(1)
if err := verifyIntValue(framework.DebugVars(), "RowcacheSpotCheckRatio", 1); err != nil {
t.Error(err)
}
vstart = framework.DebugVars()
_, err = client.Execute("select * from vtocc_cached2 where eid = 2 and bid = 'foo'", nil)
if err != nil {
t.Error(err)
return
}
if err := compareIntDiff(framework.DebugVars(), "RowcacheSpotCheckCount", vstart, 1); err != nil {
t.Error(err)
}
vstart = framework.DebugVars()
_, err = client.Execute("select * from vtocc_cached1 where eid in (9)", nil)
if err != nil {
t.Error(err)
return
}
if err := compareIntDiff(framework.DebugVars(), "RowcacheSpotCheckCount", vstart, 0); err != nil {
t.Error(err)
}
_, err = client.Execute("select * from vtocc_cached1 where eid in (9)", nil)
if err != nil {
t.Error(err)
return
}
if err := compareIntDiff(framework.DebugVars(), "RowcacheSpotCheckCount", vstart, 1); err != nil {
t.Error(err)
}
}
func verifyVtoccCached2(t *testing.T, table string) error {
client := framework.NewDefaultClient()
query := fmt.Sprintf("select * from %s where eid = 2 and bid = 'foo'", table)
_, err := client.Execute(query, nil)
if err != nil {
return err
}
tstart := framework.TableStats()[table]
_, err = client.Execute(query, nil)
if err != nil {
return err
}
tend := framework.TableStats()[table]
if tend.Hits != tstart.Hits+1 {
return fmt.Errorf("Hits: %d, want %d", tend.Hits, tstart.Hits+1)
}
return nil
}
func TestSimpleRead(t *testing.T) {
vstart := framework.DebugVars()
_, err := framework.NewDefaultClient().Execute("select * from vtocc_test where intval=1", nil)
if err != nil {
t.Error(err)
return
}
vend := framework.DebugVars()
v1 := framework.FetchInt(vstart, "Queries.TotalCount")
v2 := framework.FetchInt(vend, "Queries.TotalCount")
if v1+1 != v2 {
t.Errorf("Queries.TotalCount: %d, want %d", v1+1, v2)
}
v1 = framework.FetchInt(vstart, "Queries.Histograms.PASS_SELECT.Count")
v2 = framework.FetchInt(vend, "Queries.Histograms.PASS_SELECT.Count")
if v1+1 != v2 {
t.Errorf("Queries...Count: %d, want %d", v1+1, v2)
}
}
func TestQueryRules(t *testing.T) {
rules := tabletserver.NewQueryRules()
err := rules.UnmarshalJSON(rulesJSON)
if err != nil {
t.Error(err)
return
}
err = framework.DefaultServer.SetQueryRules("endtoend", rules)
want := "Rule source identifier endtoend is not valid"
if err == nil || err.Error() != want {
t.Errorf("Error: %v, want %s", err, want)
}
framework.DefaultServer.RegisterQueryRuleSource("endtoend")
defer framework.DefaultServer.UnRegisterQueryRuleSource("endtoend")
err = framework.DefaultServer.SetQueryRules("endtoend", rules)
if err != nil {
t.Error(err)
return
}
client := framework.NewDefaultClient()
query := "select * from vtocc_test where intval=:asdfg"
bv := map[string]interface{}{"asdfg": 1}
_, err = client.Execute(query, bv)
want = "error: Query disallowed due to rule: disallow bindvar 'asdfg'"
if err == nil || err.Error() != want {
t.Errorf("Error: %v, want %s", err, want)
}
err = framework.DefaultServer.SetQueryRules("endtoend", nil)
if err != nil {
t.Error(err)
return
}
_, err = client.Execute(query, bv)
if err != nil {
t.Error(err)
return
}
}
func TestCharaterSet(t *testing.T) {
qr, err := framework.NewDefaultClient().Execute("select * from vtocc_test where intval=1", nil)
if err != nil {
t.Error(err)
return
}
want := mproto.QueryResult{
Fields: []mproto.Field{
{
Name: "intval",
Type: 3,
Flags: 0,
}, {
Name: "floatval",
Type: 4,
Flags: 0,
}, {
Name: "charval",
Type: 253,
Flags: 0,
}, {
Name: "binval",
Type: 253,
Flags: mysql.FlagBinary,
},
},
RowsAffected: 1,
Rows: [][]sqltypes.Value{
[]sqltypes.Value{
sqltypes.Value{Inner: sqltypes.Numeric("1")},
sqltypes.Value{Inner: sqltypes.Fractional("1.12345")},
sqltypes.Value{Inner: sqltypes.String("\xc2\xa2")},
sqltypes.Value{Inner: sqltypes.String("\x00\xff")},
},
},
}
if !reflect.DeepEqual(*qr, want) {
t.Errorf("Execute: \n%#v, want \n%#v", *qr, want)
}
}
func TestCacheDisallows(t *testing.T) {
client := framework.NewDefaultClient()
testCases := []struct {
query string
bv map[string]interface{}
err string
}{{
query: "select bid, eid from vtocc_cached2 where eid = 1 and bid = 1",
err: "error: type mismatch",
}, {
query: "select * from vtocc_cached2 where eid = 2 and bid = 'foo' limit :a",
bv: map[string]interface{}{"a": -1},
err: "error: negative limit",
}}
for _, tcase := range testCases {
_, err := client.Execute(tcase.query, tcase.bv)
if err == nil || !strings.HasPrefix(err.Error(), tcase.err) {
t.Errorf("Error: %v, want %s", err, tcase.err)
return
}
}
}
func TestMexResultSize(t *testing.T) {
defer framework.DefaultServer.SetMaxResultSize(framework.DefaultServer.MaxResultSize())
framework.DefaultServer.SetMaxResultSize(2)
client := framework.NewDefaultClient()
query := "select * from vtocc_test"
_, err := client.Execute(query, nil)
want := "error: Row count exceeded"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("Error: %v, must start with %s", err, want)
}
if err := verifyIntValue(framework.DebugVars(), "MaxResultSize", 2); err != nil {
t.Error(err)
}
framework.DefaultServer.SetMaxResultSize(10)
_, err = client.Execute(query, nil)
if err != nil {
t.Error(err)
return
}
}
func TestQueryCache(t *testing.T) {
defer framework.DefaultServer.SetQueryCacheCap(framework.DefaultServer.QueryCacheCap())
framework.DefaultServer.SetQueryCacheCap(1)
bindVars := map[string]interface{}{"ival1": 1, "ival2": 1}
client := framework.NewDefaultClient()
_, _ = client.Execute("select * from vtocc_test where intval=:ival1", bindVars)
_, _ = client.Execute("select * from vtocc_test where intval=:ival2", bindVars)
vend := framework.DebugVars()
if err := verifyIntValue(vend, "QueryCacheLength", 1); err != nil {
t.Error(err)
}
if err := verifyIntValue(vend, "QueryCacheSize", 1); err != nil {
t.Error(err)
}
if err := verifyIntValue(vend, "QueryCacheCapacity", 1); err != nil {
t.Error(err)
}
framework.DefaultServer.SetQueryCacheCap(10)
_, _ = client.Execute("select * from vtocc_test where intval=:ival1", bindVars)
vend = framework.DebugVars()
if err := verifyIntValue(vend, "QueryCacheLength", 2); err != nil {
t.Error(err)
}
if err := verifyIntValue(vend, "QueryCacheSize", 2); err != nil {
t.Error(err)
}
_, _ = client.Execute("select * from vtocc_test where intval=1", bindVars)
vend = framework.DebugVars()
if err := verifyIntValue(vend, "QueryCacheLength", 3); err != nil {
t.Error(err)
}
if err := verifyIntValue(vend, "QueryCacheSize", 3); err != nil {
t.Error(err)
}
}