本文整理匯總了Golang中github.com/cockroachdb/cockroach/pkg/sql/parser.NewDInt函數的典型用法代碼示例。如果您正苦於以下問題:Golang NewDInt函數的具體用法?Golang NewDInt怎麽用?Golang NewDInt使用的例子?那麽, 這裏精選的函數代碼示例或許可以為您提供幫助。
在下文中一共展示了NewDInt函數的15個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於係統推薦出更棒的Golang代碼示例。
示例1: benchmarkWriteArray
func benchmarkWriteArray(b *testing.B, format formatCode) {
i1 := parser.NewDInt(1234)
i2 := parser.NewDInt(1234)
i3 := parser.NewDInt(1234)
a := &parser.DArray{i1, i2, i3}
benchmarkWriteType(b, a, format)
}
示例2: checkEquivExpr
func checkEquivExpr(a, b parser.TypedExpr, sel *selectNode) error {
// The expressions above only use the values 1 and 2. Verify that the
// simplified expressions evaluate to the same value as the original
// expression for interesting values.
for _, v := range []parser.Datum{
parser.NewDInt(0),
parser.NewDInt(1),
parser.NewDInt(2),
parser.NewDInt(3),
parser.DNull,
} {
for i := range sel.curSourceRow {
sel.curSourceRow[i] = v
}
ctx := &parser.EvalContext{}
da, err := a.Eval(ctx)
if err != nil {
return fmt.Errorf("%s: %v", a, err)
}
db, err := b.Eval(ctx)
if err != nil {
return fmt.Errorf("%s: %v", b, err)
}
// This is tricky: we don't require the expressions to produce identical
// results, but to either both return true or both return not true (either
// false or NULL).
if (da == parser.DBoolTrue) != (db == parser.DBoolTrue) {
return fmt.Errorf("%s: %s: expected %s, but found %s", a, v, da, db)
}
}
return nil
}
示例3: golangFillQueryArguments
// golangFillQueryArguments populates the placeholder map with
// types and values from an array of Go values.
// TODO: This does not support arguments of the SQL 'Date' type, as there is not
// an equivalent type in Go's standard library. It's not currently needed by any
// of our internal tables.
func golangFillQueryArguments(pinfo *parser.PlaceholderInfo, args []interface{}) {
pinfo.Clear()
for i, arg := range args {
k := fmt.Sprint(i + 1)
if arg == nil {
pinfo.SetValue(k, parser.DNull)
continue
}
// A type switch to handle a few explicit types with special semantics:
// - Datums are passed along as is.
// - Time datatypes get special representation in the database.
var d parser.Datum
switch t := arg.(type) {
case parser.Datum:
d = t
case time.Time:
d = parser.MakeDTimestamp(t, time.Microsecond)
case time.Duration:
d = &parser.DInterval{Duration: duration.Duration{Nanos: t.Nanoseconds()}}
case *inf.Dec:
dd := &parser.DDecimal{}
dd.Set(t)
d = dd
}
if d == nil {
// Handle all types which have an underlying type that can be stored in the
// database.
// Note: if this reflection becomes a performance concern in the future,
// commonly used types could be added explicitly into the type switch above
// for a performance gain.
val := reflect.ValueOf(arg)
switch val.Kind() {
case reflect.Bool:
d = parser.MakeDBool(parser.DBool(val.Bool()))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
d = parser.NewDInt(parser.DInt(val.Int()))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
d = parser.NewDInt(parser.DInt(val.Uint()))
case reflect.Float32, reflect.Float64:
d = parser.NewDFloat(parser.DFloat(val.Float()))
case reflect.String:
d = parser.NewDString(val.String())
case reflect.Slice:
// Handle byte slices.
if val.Type().Elem().Kind() == reflect.Uint8 {
d = parser.NewDBytes(parser.DBytes(val.Bytes()))
}
}
if d == nil {
panic(fmt.Sprintf("unexpected type %T", arg))
}
}
pinfo.SetValue(k, d)
}
}
示例4: benchmarkWriteTuple
func benchmarkWriteTuple(b *testing.B, format formatCode) {
i := parser.NewDInt(1234)
f := parser.NewDFloat(12.34)
s := parser.NewDString("testing")
t := &parser.DTuple{i, f, s}
benchmarkWriteType(b, t, format)
}
示例5: populateExplain
// populateExplain invokes explain() with a makeRow method
// which populates a valuesNode.
func (e *explainer) populateExplain(v *valuesNode, plan planNode) error {
e.makeRow = func(level int, name, field, description string, plan planNode) {
if e.err != nil {
return
}
row := parser.DTuple{
parser.NewDInt(parser.DInt(level)),
parser.NewDString(name),
parser.NewDString(field),
parser.NewDString(description),
}
if e.showMetadata {
if plan != nil {
row = append(row, parser.NewDString(formatColumns(plan.Columns(), e.showTypes)))
row = append(row, parser.NewDString(plan.Ordering().AsString(plan.Columns())))
} else {
row = append(row, emptyString, emptyString)
}
}
if _, err := v.rows.AddRow(row); err != nil {
e.err = err
}
}
e.err = nil
e.explain(plan)
return e.err
}
示例6: benchmarkWriteArray
func benchmarkWriteArray(b *testing.B, format formatCode) {
a := parser.NewDArray(parser.TypeInt)
for i := 0; i < 3; i++ {
if err := a.Append(parser.NewDInt(parser.DInt(1234))); err != nil {
b.Fatal(err)
}
}
benchmarkWriteType(b, a, format)
}
示例7: Next
func (o *ordinalityNode) Next() (bool, error) {
hasNext, err := o.source.Next()
if !hasNext || err != nil {
return hasNext, err
}
copy(o.row, o.source.Values())
// o.row was allocated one spot larger than o.source.Values().
// Store the ordinality value there.
o.row[len(o.row)-1] = parser.NewDInt(parser.DInt(o.curCnt))
o.curCnt++
return true, nil
}
示例8: colIDArrayToDatum
// colIDArrayToDatum returns an int[] containing the ColumnIDs, or NULL if there
// are no ColumnIDs.
func colIDArrayToDatum(arr []sqlbase.ColumnID) (parser.Datum, error) {
if len(arr) == 0 {
return parser.DNull, nil
}
d := parser.NewDArray(parser.TypeInt)
for _, val := range arr {
if err := d.Append(parser.NewDInt(parser.DInt(val))); err != nil {
return nil, err
}
}
return d, nil
}
示例9: TestRowContainer
func TestRowContainer(t *testing.T) {
defer leaktest.AfterTest(t)()
for _, numCols := range []int{1, 2, 3, 5, 10, 15} {
for _, numRows := range []int{5, 10, 100} {
for _, numPops := range []int{0, 1, 2, numRows / 3, numRows / 2} {
resCol := make(ResultColumns, numCols)
for i := range resCol {
resCol[i] = ResultColumn{Typ: parser.TypeInt}
}
m := mon.MakeUnlimitedMonitor(context.Background(), "test", nil, nil, math.MaxInt64)
rc := NewRowContainer(m.MakeBoundAccount(context.Background()), resCol, 0)
row := make(parser.DTuple, numCols)
for i := 0; i < numRows; i++ {
for j := range row {
row[j] = parser.NewDInt(parser.DInt(i*numCols + j))
}
if err := rc.AddRow(row); err != nil {
t.Fatal(err)
}
}
for i := 0; i < numPops; i++ {
rc.PopFirst()
}
// Given that we just deleted numPops rows, we have numRows -
// numPops rows remaining.
if rc.Len() != numRows-numPops {
t.Fatalf("invalid length, expected %d got %d", numRows-numPops, rc.Len())
}
// what was previously rc.At(i + numPops) is now rc.At(i).
for i := 0; i < rc.Len(); i++ {
row := rc.At(i)
for j := range row {
dint, ok := row[j].(*parser.DInt)
if !ok || int(*dint) != (i+numPops)*numCols+j {
t.Fatalf("invalid value %+v on row %d, col %d", row[j], i+numPops, j)
}
}
}
}
}
}
}
示例10: RandDatum
// RandDatum generates a random Datum of the given type.
// If null is true, the datum can be DNull.
func RandDatum(rng *rand.Rand, typ ColumnType_Kind, null bool) parser.Datum {
if null && rng.Intn(10) == 0 {
return parser.DNull
}
switch typ {
case ColumnType_BOOL:
return parser.MakeDBool(rng.Intn(2) == 1)
case ColumnType_INT:
return parser.NewDInt(parser.DInt(rng.Int63()))
case ColumnType_FLOAT:
return parser.NewDFloat(parser.DFloat(rng.NormFloat64()))
case ColumnType_DECIMAL:
d := &parser.DDecimal{}
d.Dec.SetScale(inf.Scale(rng.Intn(40) - 20))
d.Dec.SetUnscaled(rng.Int63())
return d
case ColumnType_DATE:
return parser.NewDDate(parser.DDate(rng.Intn(10000)))
case ColumnType_TIMESTAMP:
return &parser.DTimestamp{Time: time.Unix(rng.Int63n(1000000), rng.Int63n(1000000))}
case ColumnType_INTERVAL:
return &parser.DInterval{Duration: duration.Duration{Months: rng.Int63n(1000),
Days: rng.Int63n(1000),
Nanos: rng.Int63n(1000000),
}}
case ColumnType_STRING:
// Generate a random ASCII string.
p := make([]byte, rng.Intn(10))
for i := range p {
p[i] = byte(1 + rng.Intn(127))
}
return parser.NewDString(string(p))
case ColumnType_BYTES:
p := make([]byte, rng.Intn(10))
_, _ = rng.Read(p)
return parser.NewDBytes(parser.DBytes(p))
case ColumnType_TIMESTAMPTZ:
return &parser.DTimestampTZ{Time: time.Unix(rng.Int63n(1000000), rng.Int63n(1000000))}
case ColumnType_INT_ARRAY:
// TODO(cuongdo): we don't support for persistence of arrays yet
return parser.DNull
default:
panic(fmt.Sprintf("invalid type %s", typ))
}
}
示例11: MakePrimaryIndexKey
// MakePrimaryIndexKey creates a key prefix that corresponds to a table row
// (in the primary index); it is intended for tests.
//
// The value types must match the primary key columns (or a prefix of them);
// supported types are: - Datum
// - bool (converts to DBool)
// - int (converts to DInt)
// - string (converts to DString)
func MakePrimaryIndexKey(desc *TableDescriptor, vals ...interface{}) (roachpb.Key, error) {
index := &desc.PrimaryIndex
if len(vals) > len(index.ColumnIDs) {
return nil, errors.Errorf("got %d values, PK has %d columns", len(vals), len(index.ColumnIDs))
}
datums := make([]parser.Datum, len(vals))
for i, v := range vals {
switch v := v.(type) {
case bool:
datums[i] = parser.MakeDBool(parser.DBool(v))
case int:
datums[i] = parser.NewDInt(parser.DInt(v))
case string:
datums[i] = parser.NewDString(v)
case parser.Datum:
datums[i] = v
default:
return nil, errors.Errorf("unexpected value type %T", v)
}
// Check that the value type matches.
colID := index.ColumnIDs[i]
for _, c := range desc.Columns {
if c.ID == colID {
if t := DatumTypeToColumnKind(datums[i].ResolvedType()); t != c.Type.Kind {
return nil, errors.Errorf("column %d of type %s, got value of type %s", i, c.Type.Kind, t)
}
break
}
}
}
// Create the ColumnID to index in datums slice map needed by
// MakeIndexKeyPrefix.
colIDToRowIndex := make(map[ColumnID]int)
for i := range vals {
colIDToRowIndex[index.ColumnIDs[i]] = i
}
keyPrefix := MakeIndexKeyPrefix(desc, index.ID)
key, _, err := EncodeIndexKey(desc, index, colIDToRowIndex, datums, keyPrefix)
if err != nil {
return nil, err
}
return roachpb.Key(key), nil
}
示例12: TestTableReader
func TestTableReader(t *testing.T) {
defer leaktest.AfterTest(t)()
s, sqlDB, kvDB := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
// Create a table where each row is:
//
// | a | b | sum | s |
// |-----------------------------------------------------------------|
// | rowId/10 | rowId%10 | rowId/10 + rowId%10 | IntToEnglish(rowId) |
aFn := func(row int) parser.Datum {
return parser.NewDInt(parser.DInt(row / 10))
}
bFn := func(row int) parser.Datum {
return parser.NewDInt(parser.DInt(row % 10))
}
sumFn := func(row int) parser.Datum {
return parser.NewDInt(parser.DInt(row/10 + row%10))
}
sqlutils.CreateTable(t, sqlDB, "t",
"a INT, b INT, sum INT, s STRING, PRIMARY KEY (a,b), INDEX bs (b,s)",
99,
sqlutils.ToRowFn(aFn, bFn, sumFn, sqlutils.RowEnglishFn))
td := sqlbase.GetTableDescriptor(kvDB, "test", "t")
makeIndexSpan := func(start, end int) TableReaderSpan {
var span roachpb.Span
prefix := roachpb.Key(sqlbase.MakeIndexKeyPrefix(td, td.Indexes[0].ID))
span.Key = append(prefix, encoding.EncodeVarintAscending(nil, int64(start))...)
span.EndKey = append(span.EndKey, prefix...)
span.EndKey = append(span.EndKey, encoding.EncodeVarintAscending(nil, int64(end))...)
return TableReaderSpan{Span: span}
}
testCases := []struct {
spec TableReaderSpec
expected string
}{
{
spec: TableReaderSpec{
Filter: Expression{Expr: "@3 < 5 AND @2 != 3"}, // sum < 5 && b != 3
OutputColumns: []uint32{0, 1},
},
expected: "[[0 1] [0 2] [0 4] [1 0] [1 1] [1 2] [2 0] [2 1] [2 2] [3 0] [3 1] [4 0]]",
},
{
spec: TableReaderSpec{
Filter: Expression{Expr: "@3 < 5 AND @2 != 3"},
OutputColumns: []uint32{3}, // s
HardLimit: 4,
},
expected: "[['one'] ['two'] ['four'] ['one-zero']]",
},
{
spec: TableReaderSpec{
IndexIdx: 1,
Reverse: true,
Spans: []TableReaderSpan{makeIndexSpan(4, 6)},
Filter: Expression{Expr: "@1 < 3"}, // sum < 8
OutputColumns: []uint32{0, 1},
SoftLimit: 1,
},
expected: "[[2 5] [1 5] [0 5] [2 4] [1 4] [0 4]]",
},
}
for _, c := range testCases {
ts := c.spec
ts.Table = *td
flowCtx := FlowCtx{
Context: context.Background(),
evalCtx: &parser.EvalContext{},
txnProto: &roachpb.Transaction{},
clientDB: kvDB,
}
out := &RowBuffer{}
tr, err := newTableReader(&flowCtx, &ts, out)
if err != nil {
t.Fatal(err)
}
tr.Run(nil)
if out.err != nil {
t.Fatal(out.err)
}
if !out.closed {
t.Fatalf("output RowReceiver not closed")
}
if result := out.rows.String(); result != c.expected {
t.Errorf("invalid results: %s, expected %s'", result, c.expected)
}
}
}
示例13: TestEncDatum
func TestEncDatum(t *testing.T) {
defer leaktest.AfterTest(t)()
a := &DatumAlloc{}
v := EncDatum{}
if !v.IsUnset() {
t.Errorf("empty EncDatum should be unset")
}
if _, ok := v.Encoding(); ok {
t.Errorf("empty EncDatum has an encoding")
}
x := DatumToEncDatum(ColumnType{Kind: ColumnType_INT}, parser.NewDInt(5))
if x.IsUnset() {
t.Errorf("unset after DatumToEncDatum()")
}
if x.IsNull() {
t.Errorf("null after DatumToEncDatum()")
}
encoded, err := x.Encode(a, DatumEncoding_ASCENDING_KEY, nil)
if err != nil {
t.Fatal(err)
}
y := EncDatumFromEncoded(ColumnType{Kind: ColumnType_INT}, DatumEncoding_ASCENDING_KEY, encoded)
if y.IsUnset() {
t.Errorf("unset after EncDatumFromEncoded")
}
if y.IsNull() {
t.Errorf("null after EncDatumFromEncoded")
}
if enc, ok := y.Encoding(); !ok {
t.Error("no encoding after EncDatumFromEncoded")
} else if enc != DatumEncoding_ASCENDING_KEY {
t.Errorf("invalid encoding %d", enc)
}
err = y.EnsureDecoded(a)
if err != nil {
t.Fatal(err)
}
if cmp := y.Datum.Compare(x.Datum); cmp != 0 {
t.Errorf("Datums should be equal, cmp = %d", cmp)
}
enc2, err := y.Encode(a, DatumEncoding_DESCENDING_KEY, nil)
if err != nil {
t.Fatal(err)
}
// y's encoding should not change.
if enc, ok := y.Encoding(); !ok {
t.Error("no encoding")
} else if enc != DatumEncoding_ASCENDING_KEY {
t.Errorf("invalid encoding %d", enc)
}
z := EncDatumFromEncoded(ColumnType{Kind: ColumnType_INT}, DatumEncoding_DESCENDING_KEY, enc2)
if enc, ok := z.Encoding(); !ok {
t.Error("no encoding")
} else if enc != DatumEncoding_DESCENDING_KEY {
t.Errorf("invalid encoding %d", enc)
}
if z.IsNull() {
t.Errorf("null after EncDatumFromEncoded")
}
err = z.EnsureDecoded(a)
if err != nil {
t.Fatal(err)
}
if cmp := y.Datum.Compare(z.Datum); cmp != 0 {
t.Errorf("Datums should be equal, cmp = %d", cmp)
}
y.UnsetDatum()
if !y.IsUnset() {
t.Error("not unset after UnsetDatum()")
}
}
示例14: TestSorter
func TestSorter(t *testing.T) {
defer leaktest.AfterTest(t)()
v := [6]sqlbase.EncDatum{}
for i := range v {
v[i].SetDatum(sqlbase.ColumnType_INT, parser.NewDInt(parser.DInt(i)))
}
asc := encoding.Ascending
desc := encoding.Descending
testCases := []struct {
spec SorterSpec
input sqlbase.EncDatumRows
expected sqlbase.EncDatumRows
}{
{
// No specified input ordering and unspecified limit.
spec: SorterSpec{
OutputOrdering: convertToSpecOrdering(
sqlbase.ColumnOrdering{
{ColIdx: 0, Direction: asc},
{ColIdx: 1, Direction: desc},
{ColIdx: 2, Direction: asc},
}),
},
input: sqlbase.EncDatumRows{
{v[1], v[0], v[4]},
{v[3], v[4], v[1]},
{v[4], v[4], v[4]},
{v[3], v[2], v[0]},
{v[4], v[4], v[5]},
{v[3], v[3], v[0]},
{v[0], v[0], v[0]},
},
expected: sqlbase.EncDatumRows{
{v[0], v[0], v[0]},
{v[1], v[0], v[4]},
{v[3], v[4], v[1]},
{v[3], v[3], v[0]},
{v[3], v[2], v[0]},
{v[4], v[4], v[4]},
{v[4], v[4], v[5]},
},
}, {
// No specified input ordering but specified limit.
spec: SorterSpec{
Limit: 4,
OutputOrdering: convertToSpecOrdering(
sqlbase.ColumnOrdering{
{ColIdx: 0, Direction: asc},
{ColIdx: 1, Direction: asc},
{ColIdx: 2, Direction: asc},
}),
},
input: sqlbase.EncDatumRows{
{v[3], v[3], v[0]},
{v[3], v[4], v[1]},
{v[1], v[0], v[4]},
{v[0], v[0], v[0]},
{v[4], v[4], v[4]},
{v[4], v[4], v[5]},
{v[3], v[2], v[0]},
},
expected: sqlbase.EncDatumRows{
{v[0], v[0], v[0]},
{v[1], v[0], v[4]},
{v[3], v[2], v[0]},
{v[3], v[3], v[0]},
},
}, {
// Specified match ordering length but no specified limit.
spec: SorterSpec{
OrderingMatchLen: 2,
OutputOrdering: convertToSpecOrdering(
sqlbase.ColumnOrdering{
{ColIdx: 0, Direction: asc},
{ColIdx: 1, Direction: asc},
{ColIdx: 2, Direction: asc},
}),
},
input: sqlbase.EncDatumRows{
{v[0], v[1], v[2]},
{v[0], v[1], v[0]},
{v[1], v[0], v[5]},
{v[1], v[1], v[5]},
{v[1], v[1], v[4]},
{v[3], v[4], v[3]},
{v[3], v[4], v[2]},
{v[3], v[5], v[1]},
{v[4], v[4], v[5]},
{v[4], v[4], v[4]},
},
expected: sqlbase.EncDatumRows{
{v[0], v[1], v[0]},
{v[0], v[1], v[2]},
{v[1], v[0], v[5]},
{v[1], v[1], v[4]},
{v[1], v[1], v[5]},
{v[3], v[4], v[2]},
{v[3], v[4], v[3]},
//.........這裏部分代碼省略.........
示例15: TestAdminAPIZoneDetails
// TestAdminAPIZoneDetails verifies the zone configuration information returned
// for both DatabaseDetailsResponse AND TableDetailsResponse.
func TestAdminAPIZoneDetails(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
ts := s.(*TestServer)
// Create database and table.
ac := log.AmbientContext{Tracer: tracing.NewTracer()}
ctx, span := ac.AnnotateCtxWithSpan(context.Background(), "test")
defer span.Finish()
session := sql.NewSession(
ctx, sql.SessionArgs{User: security.RootUser}, ts.sqlExecutor, nil, &sql.MemoryMetrics{})
session.StartUnlimitedMonitor()
setupQueries := []string{
"CREATE DATABASE test",
"CREATE TABLE test.tbl (val STRING)",
}
for _, q := range setupQueries {
res := ts.sqlExecutor.ExecuteStatements(session, q, nil)
defer res.Close()
if res.ResultList[0].Err != nil {
t.Fatalf("error executing '%s': %s", q, res.ResultList[0].Err)
}
}
// Function to verify the zone for table "test.tbl" as returned by the Admin
// API.
verifyTblZone := func(
expectedZone config.ZoneConfig, expectedLevel serverpb.ZoneConfigurationLevel,
) {
var resp serverpb.TableDetailsResponse
if err := getAdminJSONProto(s, "databases/test/tables/tbl", &resp); err != nil {
t.Fatal(err)
}
if a, e := &resp.ZoneConfig, &expectedZone; !proto.Equal(a, e) {
t.Errorf("actual table zone config %v did not match expected value %v", a, e)
}
if a, e := resp.ZoneConfigLevel, expectedLevel; a != e {
t.Errorf("actual table ZoneConfigurationLevel %s did not match expected value %s", a, e)
}
if t.Failed() {
t.FailNow()
}
}
// Function to verify the zone for database "test" as returned by the Admin
// API.
verifyDbZone := func(
expectedZone config.ZoneConfig, expectedLevel serverpb.ZoneConfigurationLevel,
) {
var resp serverpb.DatabaseDetailsResponse
if err := getAdminJSONProto(s, "databases/test", &resp); err != nil {
t.Fatal(err)
}
if a, e := &resp.ZoneConfig, &expectedZone; !proto.Equal(a, e) {
t.Errorf("actual db zone config %v did not match expected value %v", a, e)
}
if a, e := resp.ZoneConfigLevel, expectedLevel; a != e {
t.Errorf("actual db ZoneConfigurationLevel %s did not match expected value %s", a, e)
}
if t.Failed() {
t.FailNow()
}
}
// Function to store a zone config for a given object ID.
setZone := func(zoneCfg config.ZoneConfig, id sqlbase.ID) {
zoneBytes, err := zoneCfg.Marshal()
if err != nil {
t.Fatal(err)
}
const query = `INSERT INTO system.zones VALUES($1, $2)`
params := parser.NewPlaceholderInfo()
params.SetValue(`1`, parser.NewDInt(parser.DInt(id)))
params.SetValue(`2`, parser.NewDBytes(parser.DBytes(zoneBytes)))
res := ts.sqlExecutor.ExecuteStatements(session, query, params)
defer res.Close()
if res.ResultList[0].Err != nil {
t.Fatalf("error executing '%s': %s", query, res.ResultList[0].Err)
}
}
// Verify zone matches cluster default.
verifyDbZone(config.DefaultZoneConfig(), serverpb.ZoneConfigurationLevel_CLUSTER)
verifyTblZone(config.DefaultZoneConfig(), serverpb.ZoneConfigurationLevel_CLUSTER)
// Get ID path for table. This will be an array of three IDs, containing the ID of the root namespace,
// the database, and the table (in that order).
idPath, err := ts.admin.queryDescriptorIDPath(session, []string{"test", "tbl"})
if err != nil {
t.Fatal(err)
}
// Apply zone configuration to database and check again.
dbZone := config.ZoneConfig{
RangeMinBytes: 456,
}
setZone(dbZone, idPath[1])
//.........這裏部分代碼省略.........