本文整理匯總了Golang中github.com/cockroachdb/cockroach/sql/parser.NewDInt函數的典型用法代碼示例。如果您正苦於以下問題:Golang NewDInt函數的具體用法?Golang NewDInt怎麽用?Golang NewDInt使用的例子?那麽, 這裏精選的函數代碼示例或許可以為您提供幫助。
在下文中一共展示了NewDInt函數的15個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於係統推薦出更棒的Golang代碼示例。
示例1: checkEquivExpr
func checkEquivExpr(a, b parser.TypedExpr, qvals qvalMap) 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 _, q := range qvals {
q.datum = v
}
da, err := a.Eval(parser.EvalContext{})
if err != nil {
return fmt.Errorf("%s: %v", a, err)
}
db, err := b.Eval(parser.EvalContext{})
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
}
示例2: 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)
}
}
示例3: Arg
// Arg implements the parser.Args interface.
// 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 (gp golangParameters) Arg(name string) (parser.Datum, bool) {
i, err := processPositionalArgument(name)
if err != nil {
return nil, false
}
if i < 1 || int(i) > len(gp) {
return nil, false
}
arg := gp[i-1]
if arg == nil {
return parser.DNull, true
}
// A type switch to handle a few explicit types with special semantics.
switch t := arg.(type) {
// Datums are passed along as is.
case parser.Datum:
return t, true
// Time datatypes get special representation in the database.
case time.Time:
return parser.MakeDTimestamp(t, time.Microsecond), true
case time.Duration:
return &parser.DInterval{Duration: duration.Duration{Nanos: t.Nanoseconds()}}, true
case *inf.Dec:
dd := &parser.DDecimal{}
dd.Set(t)
return dd, true
}
// 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:
return parser.MakeDBool(parser.DBool(val.Bool())), true
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return parser.NewDInt(parser.DInt(val.Int())), true
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return parser.NewDInt(parser.DInt(val.Uint())), true
case reflect.Float32, reflect.Float64:
return parser.NewDFloat(parser.DFloat(val.Float())), true
case reflect.String:
return parser.NewDString(val.String()), true
case reflect.Slice:
// Handle byte slices.
if val.Type().Elem().Kind() == reflect.Uint8 {
return parser.NewDBytes(parser.DBytes(val.Bytes())), true
}
}
panic(fmt.Sprintf("unexpected type %T", arg))
}
示例4: Events
// Events is an endpoint that returns the latest event log entries, with the following
// optional URL parameters:
//
// type=STRING returns events with this type (e.g. "create_table")
// targetID=INT returns events for that have this targetID
func (s *adminServer) Events(ctx context.Context, req *serverpb.EventsRequest) (*serverpb.EventsResponse, error) {
args := sql.SessionArgs{User: s.getUser(req)}
session := sql.NewSession(ctx, args, s.server.sqlExecutor, nil)
// Execute the query.
q := makeSQLQuery()
q.Append("SELECT timestamp, eventType, targetID, reportingID, info, uniqueID ")
q.Append("FROM system.eventlog ")
q.Append("WHERE true ") // This simplifies the WHERE clause logic below.
if len(req.Type) > 0 {
q.Append("AND eventType = $ ", parser.NewDString(req.Type))
}
if req.TargetId > 0 {
q.Append("AND targetID = $ ", parser.NewDInt(parser.DInt(req.TargetId)))
}
q.Append("ORDER BY timestamp DESC ")
q.Append("LIMIT $", parser.NewDInt(parser.DInt(apiEventLimit)))
if len(q.Errors()) > 0 {
return nil, s.serverErrors(q.Errors())
}
r := s.server.sqlExecutor.ExecuteStatements(session, q.String(), q.QueryArguments())
if err := s.checkQueryResults(r.ResultList, 1); err != nil {
return nil, s.serverError(err)
}
// Marshal response.
var resp serverpb.EventsResponse
scanner := makeResultScanner(r.ResultList[0].Columns)
for _, row := range r.ResultList[0].Rows {
var event serverpb.EventsResponse_Event
var ts time.Time
if err := scanner.ScanIndex(row, 0, &ts); err != nil {
return nil, err
}
event.Timestamp = serverpb.EventsResponse_Event_Timestamp{Sec: ts.Unix(), Nsec: uint32(ts.Nanosecond())}
if err := scanner.ScanIndex(row, 1, &event.EventType); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 2, &event.TargetID); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 3, &event.ReportingID); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 4, &event.Info); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 5, &event.UniqueID); err != nil {
return nil, err
}
resp.Events = append(resp.Events, event)
}
return &resp, nil
}
示例5: queryNamespaceID
// queryNamespaceID queries for the ID of the namespace with the given name and
// parent ID.
func (s *adminServer) queryNamespaceID(
session *sql.Session, parentID sqlbase.ID, name string,
) (sqlbase.ID, error) {
const query = `SELECT id FROM system.namespace WHERE parentID = $1 AND name = $2`
params := parser.NewPlaceholderInfo()
params.SetValue(`1`, parser.NewDInt(parser.DInt(parentID)))
params.SetValue(`2`, parser.NewDString(name))
r := s.server.sqlExecutor.ExecuteStatements(session, query, params)
if err := s.checkQueryResults(r.ResultList, 1); err != nil {
return 0, err
}
result := r.ResultList[0]
if len(result.Rows) == 0 {
return 0, errors.Errorf("namespace %s with ParentID %d not found", name, parentID)
}
var id int64
scanner := resultScanner{}
err := scanner.ScanIndex(result.Rows[0], 0, &id)
if err != nil {
return 0, err
}
return sqlbase.ID(id), nil
}
示例6: queryZone
// queryZone retrieves the specific ZoneConfig associated with the supplied ID,
// if it exists.
func (s *adminServer) queryZone(
session *sql.Session, id sqlbase.ID,
) (config.ZoneConfig, bool, error) {
const query = `SELECT config FROM system.zones WHERE id = $1`
params := parser.NewPlaceholderInfo()
params.SetValue(`1`, parser.NewDInt(parser.DInt(id)))
r := s.server.sqlExecutor.ExecuteStatements(session, query, params)
if err := s.checkQueryResults(r.ResultList, 1); err != nil {
return config.ZoneConfig{}, false, err
}
result := r.ResultList[0]
if len(result.Rows) == 0 {
return config.ZoneConfig{}, false, nil
}
var zoneBytes []byte
scanner := resultScanner{}
err := scanner.ScanIndex(result.Rows[0], 0, &zoneBytes)
if err != nil {
return config.ZoneConfig{}, false, err
}
var zone config.ZoneConfig
if err := zone.Unmarshal(zoneBytes); err != nil {
return config.ZoneConfig{}, false, err
}
return zone, true, nil
}
示例7: makeIntTestDatum
func makeIntTestDatum(count int) []parser.Datum {
rng, _ := randutil.NewPseudoRand()
vals := make([]parser.Datum, count)
for i := range vals {
vals[i] = parser.NewDInt(parser.DInt(rng.Int63()))
}
return vals
}
示例8: ShowIndex
// ShowIndex returns all the indexes for a table.
// Privileges: Any privilege on table.
// Notes: postgres does not have a SHOW INDEXES statement.
// mysql requires some privilege for any column.
func (p *planner) ShowIndex(n *parser.ShowIndex) (planNode, error) {
tn, err := n.Table.NormalizeWithDatabaseName(p.session.Database)
if err != nil {
return nil, err
}
desc, err := p.mustGetTableDesc(tn)
if err != nil {
return nil, err
}
if err := p.anyPrivilege(desc); err != nil {
return nil, err
}
v := &valuesNode{
columns: []ResultColumn{
{Name: "Table", Typ: parser.TypeString},
{Name: "Name", Typ: parser.TypeString},
{Name: "Unique", Typ: parser.TypeBool},
{Name: "Seq", Typ: parser.TypeInt},
{Name: "Column", Typ: parser.TypeString},
{Name: "Direction", Typ: parser.TypeString},
{Name: "Storing", Typ: parser.TypeBool},
},
}
appendRow := func(index sqlbase.IndexDescriptor, colName string, sequence int,
direction string, isStored bool) {
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(tn.Table()),
parser.NewDString(index.Name),
parser.MakeDBool(parser.DBool(index.Unique)),
parser.NewDInt(parser.DInt(sequence)),
parser.NewDString(colName),
parser.NewDString(direction),
parser.MakeDBool(parser.DBool(isStored)),
})
}
for _, index := range append([]sqlbase.IndexDescriptor{desc.PrimaryIndex}, desc.Indexes...) {
sequence := 1
for i, col := range index.ColumnNames {
appendRow(index, col, sequence, index.ColumnDirections[i].String(), false)
sequence++
}
for _, col := range index.StoreColumnNames {
appendRow(index, col, sequence, "N/A", true)
sequence++
}
}
return v, nil
}
示例9: 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))}
default:
panic(fmt.Sprintf("invalid type %s", typ))
}
}
示例10: decodeOidDatum
// decodeOidDatum decodes bytes with specified Oid and format code into
// a datum.
func decodeOidDatum(id oid.Oid, code formatCode, b []byte) (parser.Datum, error) {
var d parser.Datum
switch id {
case oid.T_bool:
switch code {
case formatText:
v, err := strconv.ParseBool(string(b))
if err != nil {
return d, err
}
d = parser.MakeDBool(parser.DBool(v))
default:
return d, fmt.Errorf("unsupported bool format code: %d", code)
}
case oid.T_int2:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int16
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, fmt.Errorf("unsupported int2 format code: %d", code)
}
case oid.T_int4:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, fmt.Errorf("unsupported int4 format code: %d", code)
}
case oid.T_int8:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int64
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, fmt.Errorf("unsupported int8 format code: %d", code)
}
case oid.T_float4:
switch code {
case formatText:
f, err := strconv.ParseFloat(string(b), 64)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
case formatBinary:
var f float32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &f)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, fmt.Errorf("unsupported float4 format code: %d", code)
}
case oid.T_float8:
switch code {
case formatText:
f, err := strconv.ParseFloat(string(b), 64)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
case formatBinary:
var f float64
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &f)
if err != nil {
//.........這裏部分代碼省略.........
示例11: decodeOidDatum
// decodeOidDatum decodes bytes with specified Oid and format code into
// a datum.
func decodeOidDatum(id oid.Oid, code formatCode, b []byte) (parser.Datum, error) {
var d parser.Datum
switch id {
case oid.T_bool:
switch code {
case formatText:
v, err := strconv.ParseBool(string(b))
if err != nil {
return d, err
}
d = parser.MakeDBool(parser.DBool(v))
case formatBinary:
switch b[0] {
case 0:
d = parser.MakeDBool(false)
case 1:
d = parser.MakeDBool(true)
default:
return d, util.Errorf("unsupported binary bool: %q", b)
}
default:
return d, util.Errorf("unsupported bool format code: %s", code)
}
case oid.T_int2:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int16
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, util.Errorf("unsupported int2 format code: %s", code)
}
case oid.T_int4:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, util.Errorf("unsupported int4 format code: %s", code)
}
case oid.T_int8:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int64
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, util.Errorf("unsupported int8 format code: %s", code)
}
case oid.T_float4:
switch code {
case formatText:
f, err := strconv.ParseFloat(string(b), 64)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
case formatBinary:
var f float32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &f)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, util.Errorf("unsupported float4 format code: %s", code)
}
case oid.T_float8:
switch code {
case formatText:
//.........這裏部分代碼省略.........
示例12: TestIndexKey
func TestIndexKey(t *testing.T) {
rng, _ := randutil.NewPseudoRand()
var a DatumAlloc
tests := []indexKeyTest{
{nil, nil,
[]parser.Datum{parser.NewDInt(10)},
[]parser.Datum{parser.NewDInt(20)},
},
{[]ID{100}, nil,
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11)},
[]parser.Datum{parser.NewDInt(20)},
},
{[]ID{100, 200}, nil,
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11), parser.NewDInt(12)},
[]parser.Datum{parser.NewDInt(20)},
},
{nil, []ID{100},
[]parser.Datum{parser.NewDInt(10)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21)},
},
{[]ID{100}, []ID{100},
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21)},
},
{[]ID{100}, []ID{200},
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21)},
},
{[]ID{100, 200}, []ID{100, 300},
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11), parser.NewDInt(12)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21), parser.NewDInt(22)},
},
}
for i := 0; i < 1000; i++ {
var t indexKeyTest
t.primaryInterleaves = make([]ID, rng.Intn(10))
for j := range t.primaryInterleaves {
t.primaryInterleaves[j] = ID(1 + rng.Intn(10))
}
valuesLen := randutil.RandIntInRange(rng, len(t.primaryInterleaves)+1, len(t.primaryInterleaves)+10)
t.primaryValues = make([]parser.Datum, valuesLen)
for j := range t.primaryValues {
t.primaryValues[j] = RandDatum(rng, ColumnType_INT, true)
}
t.secondaryInterleaves = make([]ID, rng.Intn(10))
for j := range t.secondaryInterleaves {
t.secondaryInterleaves[j] = ID(1 + rng.Intn(10))
}
valuesLen = randutil.RandIntInRange(rng, len(t.secondaryInterleaves)+1, len(t.secondaryInterleaves)+10)
t.secondaryValues = make([]parser.Datum, valuesLen)
for j := range t.secondaryValues {
t.secondaryValues[j] = RandDatum(rng, ColumnType_INT, true)
}
tests = append(tests, t)
}
for i, test := range tests {
tableDesc, colMap := makeTableDescForTest(test)
testValues := append(test.primaryValues, test.secondaryValues...)
primaryKeyPrefix := MakeIndexKeyPrefix(&tableDesc, tableDesc.PrimaryIndex.ID)
primaryKey, _, err := EncodeIndexKey(
&tableDesc, &tableDesc.PrimaryIndex, colMap, testValues, primaryKeyPrefix)
if err != nil {
t.Fatal(err)
}
primaryValue := roachpb.MakeValueFromBytes(nil)
primaryIndexKV := client.KeyValue{Key: primaryKey, Value: &primaryValue}
secondaryIndexEntry, err := EncodeSecondaryIndex(
&tableDesc, &tableDesc.Indexes[0], colMap, testValues)
if err != nil {
t.Fatal(err)
}
secondaryIndexKV := client.KeyValue{
Key: secondaryIndexEntry.Key,
Value: &secondaryIndexEntry.Value,
}
checkEntry := func(index *IndexDescriptor, entry client.KeyValue) {
values, err := decodeIndex(&a, &tableDesc, index, entry.Key)
if err != nil {
t.Fatal(err)
}
for j, value := range values {
testValue := testValues[colMap[index.ColumnIDs[j]]]
if value.Compare(testValue) != 0 {
t.Fatalf("%d: value %d got %q but expected %q", i, j, value, testValue)
}
}
indexID, _, err := DecodeIndexKeyPrefix(&a, &tableDesc, entry.Key)
if err != nil {
t.Fatal(err)
//.........這裏部分代碼省略.........
示例13: TestTableReader
func TestTableReader(t *testing.T) {
defer leaktest.AfterTest(t)()
_, sqlDB, kvDB, cleanup := sqlutils.SetupServer(t)
defer cleanup()
// 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.ID, 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: "$2 < 5 AND $1 != 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: "$2 < 5 AND $1 != 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: "$0 < 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
txn := client.NewTxn(context.Background(), *kvDB)
out := &RowBuffer{}
tr, err := newTableReader(&ts, txn, out, &parser.EvalContext{})
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)
}
}
}
示例14: dIntFnOrNull
func dIntFnOrNull(fn func() (int32, bool)) parser.Datum {
if n, ok := fn(); ok {
return parser.NewDInt(parser.DInt(n))
}
return parser.DNull
}
示例15: TestEncDatum
func TestEncDatum(t *testing.T) {
a := &DatumAlloc{}
x := &EncDatum{}
if !x.IsUnset() {
t.Errorf("empty EncDatum should be unset")
}
if _, ok := x.Encoding(); ok {
t.Errorf("empty EncDatum has an encoding")
}
x.SetDatum(ColumnType_INT, parser.NewDInt(5))
if x.IsUnset() {
t.Errorf("unset after SetDatum()")
}
encoded, err := x.Encode(a, DatumEncoding_ASCENDING_KEY, nil)
if err != nil {
t.Fatal(err)
}
y := &EncDatum{}
y.SetEncoded(ColumnType_INT, DatumEncoding_ASCENDING_KEY, encoded)
if y.IsUnset() {
t.Errorf("unset after SetEncoded()")
}
if enc, ok := y.Encoding(); !ok {
t.Error("no encoding after SetEncoded")
} else if enc != DatumEncoding_ASCENDING_KEY {
t.Errorf("invalid encoding %d", enc)
}
err = y.Decode(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)
}
x.SetEncoded(ColumnType_INT, DatumEncoding_DESCENDING_KEY, enc2)
if enc, ok := x.Encoding(); !ok {
t.Error("no encoding")
} else if enc != DatumEncoding_DESCENDING_KEY {
t.Errorf("invalid encoding %d", enc)
}
err = x.Decode(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)
}
}