// 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)
}
}
// DecodeTableValue decodes a value encoded by EncodeTableValue.
func DecodeTableValue(a *DatumAlloc, valType parser.Type, b []byte) (parser.Datum, []byte, error) {
_, dataOffset, _, typ, err := encoding.DecodeValueTag(b)
if err != nil {
return nil, b, err
}
if typ == encoding.Null {
return parser.DNull, b[dataOffset:], nil
}
switch valType {
case parser.TypeBool:
var x bool
b, x, err = encoding.DecodeBoolValue(b)
// No need to chunk allocate DBool as MakeDBool returns either
// parser.DBoolTrue or parser.DBoolFalse.
return parser.MakeDBool(parser.DBool(x)), b, err
case parser.TypeInt:
var i int64
b, i, err = encoding.DecodeIntValue(b)
return a.NewDInt(parser.DInt(i)), b, err
case parser.TypeFloat:
var f float64
b, f, err = encoding.DecodeFloatValue(b)
return a.NewDFloat(parser.DFloat(f)), b, err
case parser.TypeDecimal:
var d *inf.Dec
b, d, err = encoding.DecodeDecimalValue(b)
dd := a.NewDDecimal(parser.DDecimal{})
dd.Set(d)
return dd, b, err
case parser.TypeString:
var data []byte
b, data, err = encoding.DecodeBytesValue(b)
return a.NewDString(parser.DString(data)), b, err
case parser.TypeBytes:
var data []byte
b, data, err = encoding.DecodeBytesValue(b)
return a.NewDBytes(parser.DBytes(data)), b, err
case parser.TypeDate:
var i int64
b, i, err = encoding.DecodeIntValue(b)
return a.NewDDate(parser.DDate(i)), b, err
case parser.TypeTimestamp:
var t time.Time
b, t, err = encoding.DecodeTimeValue(b)
return a.NewDTimestamp(parser.DTimestamp{Time: t}), b, err
case parser.TypeTimestampTZ:
var t time.Time
b, t, err = encoding.DecodeTimeValue(b)
return a.NewDTimestampTZ(parser.DTimestampTZ{Time: t}), b, err
case parser.TypeInterval:
var d duration.Duration
b, d, err = encoding.DecodeDurationValue(b)
return a.NewDInterval(parser.DInterval{Duration: d}), b, err
default:
return nil, nil, errors.Errorf("TODO(pmattis): decoded index value: %s", valType)
}
}
func simplifyAndExpr(n *parser.AndExpr) (parser.TypedExpr, bool) {
// a AND b AND c AND d -> [a, b, c, d]
equivalent := true
exprs := splitAndExpr(n, nil)
for i := range exprs {
var equiv bool
exprs[i], equiv = simplifyExpr(exprs[i])
if !equiv {
equivalent = false
}
if isKnownFalseOrNull(exprs[i]) {
return parser.MakeDBool(false), equivalent
}
}
// Simplifying exprs might have transformed one of the elements into an AND
// expression.
texprs, exprs := exprs, nil
for _, e := range texprs {
exprs = splitAndExpr(e, exprs)
}
// Loop over the expressions looking for simplifications.
//
// TODO(pmattis): This is O(n^2) in the number of expressions. Could be
// optimized by sorting the expressions based on the variables they contain.
outer:
for i := len(exprs) - 1; i >= 0; i-- {
for j := i - 1; j >= 0; j-- {
var equiv bool
exprs[j], exprs[i], equiv = simplifyOneAndExpr(exprs[j], exprs[i])
if !equiv {
equivalent = false
}
if isKnownFalseOrNull(exprs[j]) {
return exprs[j], equivalent
}
if isKnownTrue(exprs[i]) {
exprs[i] = nil
}
if exprs[i] == nil {
// We found a simplification. Strip off the expression that is now nil
// and continue the outer loop.
n := len(exprs) - 1
exprs[i] = exprs[n]
exprs = exprs[:n]
continue outer
}
}
}
// Reform the AND expressions.
return joinAndExprs(exprs), equivalent
}
// ShowColumns of a table.
// Privileges: Any privilege on table.
// Notes: postgres does not have a SHOW COLUMNS statement.
// mysql only returns columns you have privileges on.
func (p *planner) ShowColumns(n *parser.ShowColumns) (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
}
columns := ResultColumns{
{Name: "Field", Typ: parser.TypeString},
{Name: "Type", Typ: parser.TypeString},
{Name: "Null", Typ: parser.TypeBool},
{Name: "Default", Typ: parser.TypeString},
}
return &delayedNode{
p: p,
name: "SHOW COLUMNS FROM " + tn.String(),
columns: columns,
constructor: func(p *planner) (planNode, error) {
v := p.newContainerValuesNode(columns, 0)
for i, col := range desc.Columns {
defaultExpr := parser.DNull
if e := desc.Columns[i].DefaultExpr; e != nil {
defaultExpr = parser.NewDString(*e)
}
newRow := parser.DTuple{
parser.NewDString(desc.Columns[i].Name),
parser.NewDString(col.Type.SQLString()),
parser.MakeDBool(parser.DBool(desc.Columns[i].Nullable)),
defaultExpr,
}
if err := v.rows.AddRow(newRow); err != nil {
v.rows.Close()
return nil, err
}
}
return v, nil
},
}, nil
}
// 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))
}
}
// 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
}
// simplifyExpr transforms an expression such that it contains only expressions
// involving IndexedVars that can be used for index selection. If an expression is
// encountered that cannot be used for index selection (e.g. "func(val)") that
// part of the expression tree is considered to evaluate to true, possibly
// rendering the entire expression as true. Additionally, various
// normalizations are performed on comparison expressions. For example:
//
// (a < 1 AND a < 2) -> (a < 1)
// (a < 1 AND a > 2) -> false
// (a > 1 OR a < 2) -> true
// (a > 1 OR func(b)) -> true
//
// Note that simplification is not normalization. Normalization as performed by
// parser.NormalizeExpr returns an expression that is equivalent to the
// original. Simplification can return an expression with parts of the
// expression tree stripped out.
//
// Returns false for equivalent if the resulting expression is not equivalent
// to the original. This occurs for expressions which are currently not handled
// by simplification.
func simplifyExpr(e parser.TypedExpr) (simplified parser.TypedExpr, equivalent bool) {
if e == parser.DNull {
return e, true
}
switch t := e.(type) {
case *parser.NotExpr:
return simplifyNotExpr(t)
case *parser.AndExpr:
return simplifyAndExpr(t)
case *parser.OrExpr:
return simplifyOrExpr(t)
case *parser.ComparisonExpr:
return simplifyComparisonExpr(t)
case *parser.IndexedVar, *parser.DBool:
return e, true
}
// We don't know how to simplify expressions that fall through to here, so
// consider this part of the expression true.
return parser.MakeDBool(true), false
}
func makePrefixRange(prefix parser.DString, datum parser.TypedExpr, complete bool) parser.TypedExpr {
if complete {
return parser.NewTypedComparisonExpr(
parser.EQ,
datum,
&prefix,
)
}
if len(prefix) == 0 {
return parser.MakeDBool(true)
}
return parser.NewTypedAndExpr(
parser.NewTypedComparisonExpr(
parser.GE,
datum,
&prefix,
),
parser.NewTypedComparisonExpr(
parser.LT,
datum,
parser.NewDString(string(roachpb.Key(prefix).PrefixEnd())),
),
)
}
COLUMN_NAME STRING NOT NULL DEFAULT '',
"COLLATION" STRING NOT NULL DEFAULT '',
CARDINALITY INT NOT NULL DEFAULT 0,
DIRECTION STRING NOT NULL DEFAULT '',
STORING BOOL NOT NULL DEFAULT FALSE
);`,
populate: func(p *planner, addRow func(...parser.Datum) error) error {
return forEachTableDesc(p,
func(db *sqlbase.DatabaseDescriptor, table *sqlbase.TableDescriptor) error {
appendRow := func(index *sqlbase.IndexDescriptor, colName string, sequence int,
direction string, isStored bool) error {
return addRow(
defString, // table_catalog
parser.NewDString(db.GetName()), // table_schema
parser.NewDString(table.GetName()), // table_name
parser.MakeDBool(parser.DBool(index.Unique)), // non_unique
parser.NewDString(db.GetName()), // index_schema
parser.NewDString(index.Name), // index_name
parser.NewDInt(parser.DInt(sequence)), // seq_in_index
parser.NewDString(colName), // column_name
parser.DNull, // collation
parser.DNull, // cardinality
parser.NewDString(direction), // direction
parser.MakeDBool(parser.DBool(isStored)), // storing
)
}
return forEachIndexInTable(table, func(index *sqlbase.IndexDescriptor) error {
sequence := 1
for i, col := range index.ColumnNames {
// We add a row for each column of index.
func simplifyOneOrExpr(left, right parser.TypedExpr) (parser.TypedExpr, parser.TypedExpr, bool) {
lcmp, ok := left.(*parser.ComparisonExpr)
if !ok {
return left, right, true
}
rcmp, ok := right.(*parser.ComparisonExpr)
if !ok {
return left, right, true
}
lcmpLeft, lcmpRight := lcmp.TypedLeft(), lcmp.TypedRight()
rcmpLeft, rcmpRight := rcmp.TypedLeft(), rcmp.TypedRight()
if !isDatum(lcmpRight) || !isDatum(rcmpRight) {
return parser.MakeDBool(true), nil, false
}
if !varEqual(lcmpLeft, rcmpLeft) {
return left, right, true
}
if lcmp.Operator == parser.IsNot || rcmp.Operator == parser.IsNot {
switch lcmp.Operator {
case parser.Is:
if lcmpRight == parser.DNull && rcmpRight == parser.DNull {
// a IS NULL OR a IS NOT NULL
return parser.MakeDBool(true), nil, true
}
case parser.IsNot:
if lcmpRight == parser.DNull {
switch rcmp.Operator {
case parser.Is:
if rcmpRight == parser.DNull {
// a IS NOT NULL OR a IS NULL
return parser.MakeDBool(true), nil, true
}
case parser.IsNot:
if rcmpRight == parser.DNull {
// a IS NOT NULL OR a IS NOT NULL
return left, nil, true
}
}
}
}
return left, right, true
}
if lcmp.Operator == parser.In || rcmp.Operator == parser.In {
left, right = simplifyOneOrInExpr(lcmp, rcmp)
return left, right, true
}
if reflect.TypeOf(lcmpRight) != reflect.TypeOf(rcmpRight) {
allowCmp := false
switch lcmp.Operator {
case parser.EQ, parser.NE, parser.GT, parser.GE, parser.LT, parser.LE:
switch rcmp.Operator {
case parser.EQ, parser.NE, parser.GT, parser.GE, parser.LT, parser.LE:
// Break, permitting heterogeneous comparison.
allowCmp = true
}
}
if !allowCmp {
// If the types of the left and right datums are different, no
// simplification is possible.
return left, right, true
}
}
ldatum := lcmpRight.(parser.Datum)
rdatum := rcmpRight.(parser.Datum)
cmp := ldatum.Compare(rdatum)
// Determine which expression to use when either expression (left or right)
// is valid as a return value but their types are different. The reason
// to prefer a comparison between a column value and a datum of the same
// type is that it makes index constraint construction easier.
either := lcmp
if !ldatum.ResolvedType().Equal(rdatum.ResolvedType()) {
switch ta := lcmpLeft.(type) {
case *parser.IndexedVar:
if ta.ResolvedType().Equal(rdatum.ResolvedType()) {
either = rcmp
}
}
}
// TODO(pmattis): Figure out how to generate this logic.
switch lcmp.Operator {
case parser.EQ:
switch rcmp.Operator {
case parser.EQ:
// a = x OR a = y
if cmp == 0 {
// x = y
return either, nil, true
} else if cmp == 1 {
// x > y
ldatum, rdatum = rdatum, ldatum
}
return parser.NewTypedComparisonExpr(
parser.In,
lcmpLeft,
&parser.DTuple{ldatum, rdatum},
), nil, true
case parser.NE:
// a = x OR a != y
if cmp == 0 {
// x = y
return makeIsNotNull(lcmpLeft), nil, true
}
return right, nil, true
case parser.GT:
// a = x OR a > y
if cmp == 1 {
// x > y OR x = y
return right, nil, true
} else if cmp == 0 {
return parser.NewTypedComparisonExpr(
parser.GE,
lcmpLeft,
either.TypedRight(),
), nil, true
}
return left, right, true
case parser.GE:
// a = x OR a >= y
if cmp != -1 {
// x >= y
return right, nil, true
}
return left, right, true
case parser.LT:
// a = x OR a < y
if cmp == -1 {
// x < y OR x = y
return right, nil, true
} else if cmp == 0 {
return parser.NewTypedComparisonExpr(
parser.LE,
lcmpLeft,
either.TypedRight(),
), nil, true
}
return left, right, true
case parser.LE:
// a = x OR a <= y
if cmp != 1 {
// x <= y
return right, nil, true
}
return left, right, true
}
case parser.NE:
switch rcmp.Operator {
case parser.EQ:
// a != x OR a = y
if cmp == 0 {
// x = y
return makeIsNotNull(lcmpLeft), nil, true
}
// x != y
return left, nil, true
case parser.NE:
// a != x OR a != y
if cmp == 0 {
// x = y
return either, nil, true
}
// x != y
return makeIsNotNull(lcmpLeft), nil, true
case parser.GT:
// a != x OR a > y
if cmp == 1 {
// x > y
return makeIsNotNull(lcmpLeft), nil, true
}
// x <= y
return left, nil, true
case parser.GE:
// a != x OR a >= y
if cmp != -1 {
// x >= y
return makeIsNotNull(lcmpLeft), nil, true
}
// x < y
return left, nil, true
case parser.LT:
// a != x OR a < y
if cmp == -1 {
// x < y
return makeIsNotNull(lcmpLeft), nil, true
}
// x >= y
return left, nil, true
case parser.LE:
// a != x OR a <= y
if cmp != 1 {
// x <= y
return makeIsNotNull(lcmpLeft), nil, true
}
// x > y
return left, nil, true
}
case parser.GT:
switch rcmp.Operator {
case parser.EQ:
// a > x OR a = y
if cmp == -1 {
// x < y
return left, nil, true
} else if cmp == 0 {
return parser.NewTypedComparisonExpr(
parser.GE,
lcmpLeft,
either.TypedRight(),
), nil, true
}
// x > y
return left, right, true
case parser.NE:
// a > x OR a != y
if cmp == -1 {
// x < y
return makeIsNotNull(lcmpLeft), nil, true
}
// x >= y
return right, nil, true
case parser.GT, parser.GE:
// a > x OR (a > y OR a >= y)
if cmp == -1 {
return left, nil, true
}
return right, nil, true
case parser.LT:
// a > x OR a < y
if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.NE,
lcmpLeft,
either.TypedRight(),
), nil, true
} else if cmp == -1 {
return makeIsNotNull(lcmpLeft), nil, true
}
// x != y
return left, right, true
case parser.LE:
// a > x OR a <= y
if cmp != 1 {
// x = y
return makeIsNotNull(lcmpLeft), nil, true
}
// x != y
return left, right, true
}
case parser.GE:
switch rcmp.Operator {
case parser.EQ:
// a >= x OR a = y
if cmp != 1 {
// x >. y
return left, nil, true
}
// x < y
return left, right, true
case parser.NE:
// a >= x OR a != y
if cmp != 1 {
// x <= y
return makeIsNotNull(lcmpLeft), nil, true
}
// x > y
return right, nil, true
case parser.GT:
// a >= x OR a > y
if cmp != 1 {
// x <= y
return left, nil, true
}
// x > y
return right, nil, true
case parser.GE:
// a >= x OR a >= y
if cmp == -1 {
// x < y
return left, nil, true
}
// x >= y
return right, nil, true
case parser.LT, parser.LE:
// a >= x OR a < y
if cmp != 1 {
// x <= y
return makeIsNotNull(lcmpLeft), nil, true
}
// x > y
return left, right, true
}
case parser.LT:
switch rcmp.Operator {
case parser.EQ:
// a < x OR a = y
if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.LE,
lcmpLeft,
either.TypedRight(),
), nil, true
} else if cmp == 1 {
// x > y
return left, nil, true
}
// x < y
return left, right, true
case parser.NE:
// a < x OR a != y
if cmp == 1 {
return makeIsNotNull(lcmpLeft), nil, true
}
return right, nil, true
case parser.GT:
// a < x OR a > y
if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.NE,
lcmpLeft,
either.TypedRight(),
), nil, true
} else if cmp == 1 {
// x > y
return makeIsNotNull(lcmpLeft), nil, true
}
return left, right, true
case parser.GE:
// a < x OR a >= y
if cmp == -1 {
// x < y
return left, right, true
}
// x >= y
return makeIsNotNull(lcmpLeft), nil, true
case parser.LT, parser.LE:
// a < x OR (a < y OR a <= y)
if cmp == 1 {
// x > y
return left, nil, true
}
// x < y
return right, nil, true
}
case parser.LE:
switch rcmp.Operator {
case parser.EQ:
// a <= x OR a = y
if cmp == -1 {
// x < y
return left, right, true
}
// x >= y
return left, nil, true
case parser.NE:
// a <= x OR a != y
if cmp != -1 {
// x >= y
return makeIsNotNull(lcmpLeft), nil, true
}
// x < y
return right, nil, true
case parser.GT, parser.GE:
// a <= x OR (a > y OR a >= y)
if cmp != -1 {
// x >= y
return makeIsNotNull(lcmpLeft), nil, true
}
// x < y
return left, right, true
case parser.LT, parser.LE:
// a <= x OR a < y
if cmp == -1 {
// x < y
return right, nil, true
}
// x >= y
return left, nil, true
}
case parser.Is:
switch rcmp.Operator {
case parser.Is:
if lcmpRight == parser.DNull && rcmpRight == parser.DNull {
// a IS NULL OR a IS NULL
return left, nil, true
}
}
}
return parser.MakeDBool(true), nil, false
}
func dumpTable(w io.Writer, conn *sqlConn, origDBName, origTableName string) error {
const limit = 100
// Escape names since they can't be used in placeholders.
dbname := parser.Name(origDBName).String()
tablename := parser.Name(origTableName).String()
if err := conn.Exec(fmt.Sprintf("SET DATABASE = %s", dbname), nil); err != nil {
return err
}
// Fetch all table metadata in a transaction and its time to guarantee it
// doesn't change between the various SHOW statements.
if err := conn.Exec("BEGIN", nil); err != nil {
return err
}
vals, err := conn.QueryRow("SELECT cluster_logical_timestamp()", nil)
if err != nil {
return err
}
clusterTS := string(vals[0].([]byte))
// A previous version of the code did a SELECT on system.descriptor. This
// required the SELECT privilege to the descriptor table, which only root
// has. Allowing non-root to do this would let users see other users' table
// descriptors which is a problem in multi-tenancy.
// Fetch column types.
rows, err := conn.Query(fmt.Sprintf("SHOW COLUMNS FROM %s", tablename), nil)
if err != nil {
return err
}
vals = make([]driver.Value, 2)
coltypes := make(map[string]string)
for {
if err := rows.Next(vals); err == io.EOF {
break
} else if err != nil {
return err
}
nameI, typI := vals[0], vals[1]
name, ok := nameI.(string)
if !ok {
return fmt.Errorf("unexpected value: %T", nameI)
}
typ, ok := typI.(string)
if !ok {
return fmt.Errorf("unexpected value: %T", typI)
}
coltypes[name] = typ
}
if err := rows.Close(); err != nil {
return err
}
// index holds the names, in order, of the primary key columns.
var index []string
// Primary index is always the first index returned by SHOW INDEX.
rows, err = conn.Query(fmt.Sprintf("SHOW INDEX FROM %s", tablename), nil)
if err != nil {
return err
}
vals = make([]driver.Value, 5)
var primaryIndex string
// Find the primary index columns.
for {
if err := rows.Next(vals); err == io.EOF {
break
} else if err != nil {
return err
}
b, ok := vals[1].(string)
if !ok {
return fmt.Errorf("unexpected value: %T", vals[1])
}
if primaryIndex == "" {
primaryIndex = b
} else if primaryIndex != b {
break
}
b, ok = vals[4].(string)
if !ok {
return fmt.Errorf("unexpected value: %T", vals[4])
}
index = append(index, parser.Name(b).String())
}
if err := rows.Close(); err != nil {
return err
}
if len(index) == 0 {
return fmt.Errorf("no primary key index found")
}
indexes := strings.Join(index, ", ")
// Build the SELECT query.
var sbuf bytes.Buffer
fmt.Fprintf(&sbuf, "SELECT %s, * FROM %s@%s AS OF SYSTEM TIME %s", indexes, tablename, primaryIndex, clusterTS)
var wbuf bytes.Buffer
fmt.Fprintf(&wbuf, " WHERE ROW (%s) > ROW (", indexes)
for i := range index {
if i > 0 {
wbuf.WriteString(", ")
}
fmt.Fprintf(&wbuf, "$%d", i+1)
}
wbuf.WriteString(")")
// No WHERE clause first time, so add a place to inject it.
fmt.Fprintf(&sbuf, "%%s ORDER BY %s LIMIT %d", indexes, limit)
bs := sbuf.String()
vals, err = conn.QueryRow(fmt.Sprintf("SHOW CREATE TABLE %s", tablename), nil)
if err != nil {
return err
}
create := vals[1].(string)
if _, err := w.Write([]byte(create)); err != nil {
return err
}
if _, err := w.Write([]byte(";\n")); err != nil {
return err
}
if err := conn.Exec("COMMIT", nil); err != nil {
return err
}
// pk holds the last values of the fetched primary keys
var pk []driver.Value
q := fmt.Sprintf(bs, "")
for {
rows, err := conn.Query(q, pk)
if err != nil {
return err
}
cols := rows.Columns()
pkcols := cols[:len(index)]
cols = cols[len(index):]
inserts := make([][]string, 0, limit)
i := 0
for i < limit {
vals := make([]driver.Value, len(cols)+len(pkcols))
if err := rows.Next(vals); err == io.EOF {
break
} else if err != nil {
return err
}
if pk == nil {
q = fmt.Sprintf(bs, wbuf.String())
}
pk = vals[:len(index)]
vals = vals[len(index):]
ivals := make([]string, len(vals))
// Values need to be correctly encoded for INSERT statements in a text file.
for si, sv := range vals {
switch t := sv.(type) {
case nil:
ivals[si] = "NULL"
case bool:
ivals[si] = parser.MakeDBool(parser.DBool(t)).String()
case int64:
ivals[si] = parser.NewDInt(parser.DInt(t)).String()
case float64:
ivals[si] = parser.NewDFloat(parser.DFloat(t)).String()
case string:
ivals[si] = parser.NewDString(t).String()
case []byte:
switch ct := coltypes[cols[si]]; ct {
case "INTERVAL":
ivals[si] = fmt.Sprintf("'%s'", t)
case "BYTES":
ivals[si] = parser.NewDBytes(parser.DBytes(t)).String()
default:
// STRING and DECIMAL types can have optional length
// suffixes, so only examine the prefix of the type.
if strings.HasPrefix(coltypes[cols[si]], "STRING") {
ivals[si] = parser.NewDString(string(t)).String()
} else if strings.HasPrefix(coltypes[cols[si]], "DECIMAL") {
ivals[si] = string(t)
} else {
panic(errors.Errorf("unknown []byte type: %s, %v: %s", t, cols[si], coltypes[cols[si]]))
}
}
case time.Time:
var d parser.Datum
ct := coltypes[cols[si]]
switch ct {
case "DATE":
d = parser.NewDDateFromTime(t, time.UTC)
case "TIMESTAMP":
d = parser.MakeDTimestamp(t, time.Nanosecond)
case "TIMESTAMP WITH TIME ZONE":
d = parser.MakeDTimestampTZ(t, time.Nanosecond)
default:
panic(errors.Errorf("unknown timestamp type: %s, %v: %s", t, cols[si], coltypes[cols[si]]))
}
ivals[si] = fmt.Sprintf("'%s'", d)
default:
panic(errors.Errorf("unknown field type: %T (%s)", t, cols[si]))
}
}
inserts = append(inserts, ivals)
i++
}
for si, sv := range pk {
b, ok := sv.([]byte)
if ok && strings.HasPrefix(coltypes[pkcols[si]], "STRING") {
// Primary key strings need to be converted to a go string, but not SQL
// encoded since they aren't being written to a text file.
pk[si] = string(b)
}
}
if err := rows.Close(); err != nil {
return err
}
if i == 0 {
break
}
fmt.Fprintf(w, "\nINSERT INTO %s VALUES", tablename)
for idx, values := range inserts {
if idx > 0 {
fmt.Fprint(w, ",")
}
fmt.Fprint(w, "\n\t(")
for vi, v := range values {
if vi > 0 {
fmt.Fprint(w, ", ")
}
fmt.Fprint(w, v)
}
fmt.Fprint(w, ")")
}
fmt.Fprintln(w, ";")
if i < limit {
break
}
}
return nil
}
func simplifyComparisonExpr(n *parser.ComparisonExpr) (parser.TypedExpr, bool) {
// NormalizeExpr will have left comparisons in the form "<var> <op>
// <datum>" unless they could not be simplified further in which case
// simplifyExpr cannot handle them. For example, "lower(a) = 'foo'"
left, right := n.TypedLeft(), n.TypedRight()
if isVar(left) && isDatum(right) {
if right == parser.DNull {
switch n.Operator {
case parser.IsNotDistinctFrom:
switch left.(type) {
case *parser.IndexedVar:
// Transform "a IS NOT DISTINCT FROM NULL" into "a IS NULL".
return parser.NewTypedComparisonExpr(
parser.Is,
left,
right,
), true
}
case parser.IsDistinctFrom:
switch left.(type) {
case *parser.IndexedVar:
// Transform "a IS DISTINCT FROM NULL" into "a IS NOT NULL".
return parser.NewTypedComparisonExpr(
parser.IsNot,
left,
right,
), true
}
case parser.Is, parser.IsNot:
switch left.(type) {
case *parser.IndexedVar:
// "a IS {,NOT} NULL" can be used during index selection to restrict
// the range of scanned keys.
return n, true
}
default:
// All of the remaining comparison operators have the property that when
// comparing to NULL they evaluate to NULL (see evalComparisonOp). NULL is
// not the same as false, but in the context of a WHERE clause, NULL is
// considered not-true which is the same as false.
return parser.MakeDBool(false), true
}
}
switch n.Operator {
case parser.EQ:
// Translate "(a, b) = (1, 2)" to "(a, b) IN ((1, 2))".
switch left.(type) {
case *parser.Tuple:
return parser.NewTypedComparisonExpr(
parser.In,
left,
&parser.DTuple{right.(parser.Datum)},
), true
}
return n, true
case parser.NE, parser.GE, parser.LE:
return n, true
case parser.GT:
// This simplification is necessary so that subsequent transformation of
// > constraint to >= can use Datum.Next without concern about whether a
// next value exists. Note that if the variable (n.Left) is NULL, this
// comparison would evaluate to NULL which is equivalent to false for a
// boolean expression.
if right.(parser.Datum).IsMax() {
return parser.MakeDBool(false), true
}
return n, true
case parser.LT:
// Note that if the variable is NULL, this would evaluate to NULL which
// would equivalent to false for a boolean expression.
if right.(parser.Datum).IsMin() {
return parser.MakeDBool(false), true
}
return n, true
case parser.In, parser.NotIn:
tuple := *right.(*parser.DTuple)
if len(tuple) == 0 {
return parser.MakeDBool(false), true
}
return n, true
case parser.Like:
// a LIKE 'foo%' -> a >= "foo" AND a < "fop"
if d, ok := right.(*parser.DString); ok {
if i := strings.IndexAny(string(*d), "_%"); i >= 0 {
return makePrefixRange((*d)[:i], left, false), false
}
return makePrefixRange(*d, left, true), false
}
// TODO(pmattis): Support parser.DBytes?
case parser.SimilarTo:
// a SIMILAR TO "foo.*" -> a >= "foo" AND a < "fop"
if d, ok := right.(*parser.DString); ok {
pattern := parser.SimilarEscape(string(*d))
if re, err := regexp.Compile(pattern); err == nil {
prefix, complete := re.LiteralPrefix()
return makePrefixRange(parser.DString(prefix), left, complete), false
}
}
// TODO(pmattis): Support parser.DBytes?
}
}
return parser.MakeDBool(true), false
}
func (s *subquery) doEval() (parser.Datum, error) {
var result parser.Datum
switch s.execMode {
case execModeExists:
// For EXISTS expressions, all we want to know is if there is at least one
// result.
next, err := s.plan.Next()
s.plan.Close()
if s.err = err; err != nil {
return result, err
}
if next {
result = parser.MakeDBool(true)
}
if result == nil {
result = parser.MakeDBool(false)
}
case execModeAllRows:
fallthrough
case execModeAllRowsNormalized:
var rows parser.DTuple
next, err := s.plan.Next()
for ; next; next, err = s.plan.Next() {
values := s.plan.Values()
switch len(values) {
case 1:
// This seems hokey, but if we don't do this then the subquery expands
// to a tuple of tuples instead of a tuple of values and an expression
// like "k IN (SELECT foo FROM bar)" will fail because we're comparing
// a single value against a tuple.
rows = append(rows, values[0])
default:
// The result from plan.Values() is only valid until the next call to
// plan.Next(), so make a copy.
valuesCopy := make(parser.DTuple, len(values))
copy(valuesCopy, values)
rows = append(rows, &valuesCopy)
}
}
s.plan.Close()
if s.err = err; err != nil {
return result, err
}
if s.execMode == execModeAllRowsNormalized {
rows.Normalize()
}
result = &rows
case execModeOneRow:
result = parser.DNull
hasRow, err := s.plan.Next()
if s.err = err; err != nil {
s.plan.Close()
return result, err
}
if !hasRow {
s.plan.Close()
} else {
values := s.plan.Values()
switch len(values) {
case 1:
result = values[0]
default:
valuesCopy := make(parser.DTuple, len(values))
copy(valuesCopy, values)
result = &valuesCopy
}
another, err := s.plan.Next()
s.plan.Close()
if s.err = err; err != nil {
return result, err
}
if another {
s.err = fmt.Errorf("more than one row returned by a subquery used as an expression")
return result, s.err
}
}
}
return result, nil
}
addColumn := func(column *sqlbase.ColumnDescriptor, attRelID parser.Datum, colNum int) error {
colTyp := column.Type.ToDatumType()
return addRow(
attRelID, // attrelid
parser.NewDString(column.Name), // attname
typOid(colTyp), // atttypid
zeroVal, // attstattarget
typLen(colTyp), // attlen
parser.NewDInt(parser.DInt(colNum)), // attnum
zeroVal, // attndims
negOneVal, // attcacheoff
negOneVal, // atttypmod
parser.DNull, // attbyval (see pg_type.typbyval)
parser.DNull, // attstorage
parser.DNull, // attalign
parser.MakeDBool(parser.DBool(!column.Nullable)), // attnotnull
parser.MakeDBool(parser.DBool(column.DefaultExpr != nil)), // atthasdef
parser.MakeDBool(false), // attisdropped
parser.MakeDBool(true), // attislocal
zeroVal, // attinhcount
parser.DNull, // attacl
parser.DNull, // attoptions
parser.DNull, // attfdwoptions
)
}
// Columns for table.
colNum := 0
if err := forEachColumnInTable(table, func(column *sqlbase.ColumnDescriptor) error {
colNum++
tableID := h.TableOid(db, table)
func TestValues(t *testing.T) {
defer leaktest.AfterTest(t)()
p := makeTestPlanner()
vInt := int64(5)
vNum := 3.14159
vStr := "two furs one cub"
vBool := true
unsupp := &parser.RangeCond{}
intVal := func(v int64) *parser.NumVal {
return &parser.NumVal{Value: constant.MakeInt64(v)}
}
floatVal := func(f float64) *parser.CastExpr {
return &parser.CastExpr{
Expr: &parser.NumVal{Value: constant.MakeFloat64(f)},
Type: &parser.FloatColType{},
}
}
asRow := func(datums ...parser.Datum) []parser.DTuple {
return []parser.DTuple{datums}
}
makeValues := func(tuples ...*parser.Tuple) *parser.ValuesClause {
return &parser.ValuesClause{Tuples: tuples}
}
makeTuple := func(exprs ...parser.Expr) *parser.Tuple {
return &parser.Tuple{Exprs: exprs}
}
testCases := []struct {
stmt *parser.ValuesClause
rows []parser.DTuple
ok bool
}{
{
makeValues(makeTuple(intVal(vInt))),
asRow(parser.NewDInt(parser.DInt(vInt))),
true,
},
{
makeValues(makeTuple(intVal(vInt), intVal(vInt))),
asRow(parser.NewDInt(parser.DInt(vInt)), parser.NewDInt(parser.DInt(vInt))),
true,
},
{
makeValues(makeTuple(floatVal(vNum))),
asRow(parser.NewDFloat(parser.DFloat(vNum))),
true,
},
{
makeValues(makeTuple(parser.NewDString(vStr))),
asRow(parser.NewDString(vStr)),
true,
},
{
makeValues(makeTuple(parser.NewDBytes(parser.DBytes(vStr)))),
asRow(parser.NewDBytes(parser.DBytes(vStr))),
true,
},
{
makeValues(makeTuple(parser.MakeDBool(parser.DBool(vBool)))),
asRow(parser.MakeDBool(parser.DBool(vBool))),
true,
},
{
makeValues(makeTuple(unsupp)),
nil,
false,
},
}
for i, tc := range testCases {
plan, err := func() (_ planNode, err error) {
defer func() {
if r := recover(); r != nil {
err = errors.Errorf("%v", r)
}
}()
return p.ValuesClause(tc.stmt, nil)
}()
if err == nil != tc.ok {
t.Errorf("%d: error_expected=%t, but got error %v", i, tc.ok, err)
}
if plan != nil {
defer plan.Close()
plan, err = p.optimizePlan(plan, allColumns(plan))
if err != nil {
t.Errorf("%d: unexpected error in optimizePlan: %v", i, err)
continue
}
if err := p.startPlan(plan); err != nil {
t.Errorf("%d: unexpected error in Start: %v", i, err)
continue
}
var rows []parser.DTuple
next, err := plan.Next()
for ; next; next, err = plan.Next() {
rows = append(rows, plan.Values())
}
if err != nil {
t.Error(err)
continue
}
if !reflect.DeepEqual(rows, tc.rows) {
t.Errorf("%d: expected rows:\n%+v\nactual rows:\n%+v", i, tc.rows, rows)
}
}
}
}
// 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, null bool) parser.Datum {
if null && rng.Intn(10) == 0 {
return parser.DNull
}
switch typ.Kind {
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_COLLATEDSTRING:
if typ.Locale == nil {
panic("locale is required for COLLATEDSTRING")
}
// Generate a random Unicode string.
var buf bytes.Buffer
n := rng.Intn(10)
for i := 0; i < n; i++ {
var r rune
for {
r = rune(rng.Intn(unicode.MaxRune + 1))
if !unicode.Is(unicode.C, r) {
break
}
}
buf.WriteRune(r)
}
return parser.NewDCollatedString(buf.String(), *typ.Locale, &parser.CollationEnvironment{})
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.String()))
}
}
func simplifyNotExpr(n *parser.NotExpr) (parser.TypedExpr, bool) {
if n.Expr == parser.DNull {
return parser.DNull, true
}
switch t := n.Expr.(type) {
case *parser.ComparisonExpr:
op := t.Operator
switch op {
case parser.EQ:
op = parser.NE
case parser.NE:
op = parser.EQ
case parser.GT:
op = parser.LE
case parser.GE:
op = parser.LT
case parser.LT:
op = parser.GE
case parser.LE:
op = parser.GT
case parser.In:
op = parser.NotIn
case parser.NotIn:
op = parser.In
case parser.Like:
op = parser.NotLike
case parser.NotLike:
op = parser.Like
case parser.ILike:
op = parser.NotILike
case parser.NotILike:
op = parser.ILike
case parser.SimilarTo:
op = parser.NotSimilarTo
case parser.NotSimilarTo:
op = parser.SimilarTo
case parser.RegMatch:
op = parser.NotRegMatch
case parser.RegIMatch:
op = parser.NotRegIMatch
default:
return parser.MakeDBool(true), false
}
return simplifyExpr(parser.NewTypedComparisonExpr(
op,
t.TypedLeft(),
t.TypedRight(),
))
case *parser.AndExpr:
// De Morgan's Law: NOT (a AND b) -> (NOT a) OR (NOT b)
return simplifyExpr(parser.NewTypedOrExpr(
parser.NewTypedNotExpr(t.TypedLeft()),
parser.NewTypedNotExpr(t.TypedRight()),
))
case *parser.OrExpr:
// De Morgan's Law: NOT (a OR b) -> (NOT a) AND (NOT b)
return simplifyExpr(parser.NewTypedAndExpr(
parser.NewTypedNotExpr(t.TypedLeft()),
parser.NewTypedNotExpr(t.TypedRight()),
))
}
return parser.MakeDBool(true), false
}
func simplifyOneAndExpr(left, right parser.TypedExpr) (parser.TypedExpr, parser.TypedExpr, bool) {
lcmp, ok := left.(*parser.ComparisonExpr)
if !ok {
return left, right, true
}
rcmp, ok := right.(*parser.ComparisonExpr)
if !ok {
return left, right, true
}
lcmpLeft, lcmpRight := lcmp.TypedLeft(), lcmp.TypedRight()
rcmpLeft, rcmpRight := rcmp.TypedLeft(), rcmp.TypedRight()
if !isDatum(lcmpRight) || !isDatum(rcmpRight) {
return parser.MakeDBool(true), nil, false
}
if !varEqual(lcmpLeft, rcmpLeft) {
return left, right, true
}
if lcmp.Operator == parser.IsNot || rcmp.Operator == parser.IsNot {
switch lcmp.Operator {
case parser.EQ, parser.GT, parser.GE, parser.LT, parser.LE, parser.In:
if rcmpRight == parser.DNull {
// a <cmp> x AND a IS NOT NULL
return left, nil, true
}
case parser.Is:
if lcmpRight == parser.DNull && rcmpRight == parser.DNull {
// a IS NULL AND a IS NOT NULL
return parser.MakeDBool(false), nil, true
}
case parser.IsNot:
if lcmpRight == parser.DNull {
switch rcmp.Operator {
case parser.EQ, parser.GT, parser.GE, parser.LT, parser.LE, parser.In:
// a IS NOT NULL AND a <cmp> x
return right, nil, true
case parser.Is:
if rcmpRight == parser.DNull {
// a IS NOT NULL AND a IS NULL
return parser.MakeDBool(false), nil, true
}
case parser.IsNot:
if rcmpRight == parser.DNull {
// a IS NOT NULL AND a IS NOT NULL
return left, nil, true
}
}
}
}
return left, right, true
}
if lcmp.Operator == parser.In || rcmp.Operator == parser.In {
left, right = simplifyOneAndInExpr(lcmp, rcmp)
return left, right, true
}
if reflect.TypeOf(lcmpRight) != reflect.TypeOf(rcmpRight) {
allowCmp := false
switch lcmp.Operator {
case parser.EQ, parser.NE, parser.GT, parser.GE, parser.LT, parser.LE:
switch rcmp.Operator {
case parser.EQ, parser.NE, parser.GT, parser.GE, parser.LT, parser.LE:
// Break, permitting heterogeneous comparison.
allowCmp = true
}
}
if !allowCmp {
if lcmp.Operator == parser.Is && lcmpRight == parser.DNull {
// a IS NULL AND a <cmp> x
return parser.MakeDBool(false), nil, true
}
if rcmp.Operator == parser.Is && rcmpRight == parser.DNull {
// a <cmp> x AND a IS NULL
return parser.MakeDBool(false), nil, true
}
// Note that "a IS NULL and a IS NULL" cannot happen here because
// "reflect.TypeOf(NULL) == reflect.TypeOf(NULL)".
return left, right, true
}
}
ldatum := lcmpRight.(parser.Datum)
rdatum := rcmpRight.(parser.Datum)
cmp := ldatum.Compare(rdatum)
// Determine which expression to use when either expression (left or right)
// is valid as a return value but their types are different. The reason
// to prefer a comparison between a column value and a datum of the same
// type is that it makes index constraint construction easier.
either := lcmp
if !ldatum.ResolvedType().Equal(rdatum.ResolvedType()) {
switch ta := lcmpLeft.(type) {
case *parser.IndexedVar:
if ta.ResolvedType().Equal(rdatum.ResolvedType()) {
either = rcmp
}
}
}
// TODO(pmattis): Figure out how to generate this logic.
switch lcmp.Operator {
case parser.EQ:
switch rcmp.Operator {
case parser.EQ:
// a = x AND a = y
if cmp == 0 {
// x = y
return either, nil, true
}
return parser.MakeDBool(false), nil, true
case parser.NE:
// a = x AND a != y
if cmp == 0 {
// x = y
return parser.MakeDBool(false), nil, true
}
return left, nil, true
case parser.GT, parser.GE:
// a = x AND (a > y OR a >= y)
if cmp == -1 || (cmp == 0 && rcmp.Operator == parser.GT) {
// x < y OR x = y
return parser.MakeDBool(false), nil, true
}
return left, nil, true
case parser.LT, parser.LE:
// a = x AND (a < y OR a <= y)
if cmp == 1 || (cmp == 0 && rcmp.Operator == parser.LT) {
// x > y OR x = y
return parser.MakeDBool(false), nil, true
}
return left, nil, true
}
case parser.NE:
switch rcmp.Operator {
case parser.EQ:
// a != x AND a = y
if cmp == 0 {
// x = y
return parser.MakeDBool(false), nil, true
}
return right, nil, true
case parser.NE:
// a != x AND a != y
if cmp == 0 {
// x = y
return either, nil, true
}
return left, right, true
case parser.GT:
// a != x AND a > y
return right, nil, cmp <= 0
case parser.LT:
// a != x AND a < y
return right, nil, cmp >= 0
case parser.GE:
// a != x AND a >= y
if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.GT,
rcmpLeft,
either.TypedRight(),
), nil, true
}
// x != y
return right, nil, cmp == -1
case parser.LE:
// a != x AND a <= y
if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.LT,
rcmpLeft,
either.TypedRight(),
), nil, true
}
// x != y
return right, nil, cmp == +1
}
case parser.GT:
switch rcmp.Operator {
case parser.EQ:
// a > x AND a = y
if cmp != -1 {
// x >= y
return parser.MakeDBool(false), nil, true
}
// x < y
return right, nil, true
case parser.NE:
// a > x AND a != y
return left, nil, cmp >= 0
case parser.GT, parser.GE:
// a > x AND (a > y OR a >= y)
if cmp != -1 {
// x >= y
return left, nil, true
}
// x < y
return right, nil, true
case parser.LT, parser.LE:
// a > x AND (a < y OR a <= y)
if cmp == -1 {
// x < y
return left, right, true
}
// x >= y
return parser.MakeDBool(false), nil, true
}
case parser.GE:
switch rcmp.Operator {
case parser.EQ:
// a >= x AND a = y
if cmp == 1 {
// x > y
return parser.MakeDBool(false), nil, true
}
// x <= y
return right, nil, true
case parser.NE:
// a >= x AND x != y
if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.GT,
lcmpLeft,
either.TypedRight(),
), nil, true
}
// x != y
return left, nil, cmp == +1
case parser.GT, parser.GE:
// a >= x AND (a > y OR a >= y)
if cmp == -1 || (cmp == 0 && rcmp.Operator == parser.GT) {
// x < y
return right, nil, true
}
// x >= y
return left, nil, true
case parser.LT:
// a >= x AND a < y
if cmp == -1 {
// x < y
return left, right, true
}
// x >= y
return parser.MakeDBool(false), nil, true
case parser.LE:
// a >= x AND a <= y
if cmp == -1 {
// x < y
return left, right, true
} else if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.EQ,
lcmpLeft,
either.TypedRight(),
), nil, true
}
// x > y
return parser.MakeDBool(false), nil, true
}
case parser.LT:
switch rcmp.Operator {
case parser.EQ:
// a < x AND a = y
if cmp != 1 {
// x <= y
return parser.MakeDBool(false), nil, true
}
// x > y
return right, nil, true
case parser.NE:
// a < x AND a != y
return left, nil, cmp <= 0
case parser.GT, parser.GE:
// a < x AND (a > y OR a >= y)
if cmp == 1 {
// x > y
return left, right, true
}
// x <= y
return parser.MakeDBool(false), nil, true
case parser.LT, parser.LE:
// a < x AND (a < y OR a <= y)
if cmp != 1 {
// x <= y
return left, nil, true
}
// x > y
return right, nil, true
}
case parser.LE:
switch rcmp.Operator {
case parser.EQ:
// a <= x AND a = y
if cmp == -1 {
// x < y
return parser.MakeDBool(false), nil, true
}
// x >= y
return right, nil, true
case parser.NE:
// a <= x AND a != y
if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.LT,
lcmpLeft,
either.TypedRight(),
), nil, true
}
// x != y
return left, nil, cmp == -1
case parser.GT:
// a <= x AND a > y
if cmp == 1 {
// x > y
return left, right, true
}
return parser.MakeDBool(false), nil, true
case parser.GE:
// a <= x AND a >= y
if cmp == +1 {
// x > y
return left, right, true
} else if cmp == 0 {
// x = y
return parser.NewTypedComparisonExpr(
parser.EQ,
lcmpLeft,
either.TypedRight(),
), nil, true
}
// x < y
return parser.MakeDBool(false), nil, true
case parser.LT, parser.LE:
// a <= x AND (a > y OR a >= y)
if cmp == 1 || (cmp == 0 && rcmp.Operator == parser.LT) {
// x > y
return right, nil, true
}
// x <= y
return left, nil, true
}
case parser.Is:
switch rcmp.Operator {
case parser.Is:
if lcmpRight == parser.DNull && rcmpRight == parser.DNull {
// a IS NULL AND a IS NULL
return left, nil, true
}
}
}
return parser.MakeDBool(true), nil, false
}
addColumn := func(column *sqlbase.ColumnDescriptor, attRelID parser.Datum, colNum int) error {
colTyp := column.Type.ToDatumType()
return addRow(
attRelID, // attrelid
parser.NewDString(column.Name), // attname
typOid(colTyp), // atttypid
zeroVal, // attstattarget
typLen(colTyp), // attlen
parser.NewDInt(parser.DInt(colNum)), // attnum
zeroVal, // attndims
negOneVal, // attcacheoff
negOneVal, // atttypmod
parser.DNull, // attbyval (see pg_type.typbyval)
parser.DNull, // attstorage
parser.DNull, // attalign
parser.MakeDBool(parser.DBool(!column.Nullable)), // attnotnull
parser.MakeDBool(parser.DBool(column.DefaultExpr != nil)), // atthasdef
parser.MakeDBool(false), // attisdropped
parser.MakeDBool(true), // attislocal
zeroVal, // attinhcount
parser.DNull, // attacl
parser.DNull, // attoptions
parser.DNull, // attfdwoptions
)
}
// Columns for table.
colNum := 0
if err := forEachColumnInTable(table, func(column *sqlbase.ColumnDescriptor) error {
colNum++
tableID := h.TableOid(db, table)
// 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, errors.Errorf("unsupported binary bool: %q", b)
}
default:
return d, errors.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:
if len(b) < 2 {
return d, errors.Errorf("int2 requires 2 bytes for binary format")
}
i := int16(binary.BigEndian.Uint16(b))
d = parser.NewDInt(parser.DInt(i))
default:
return d, errors.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:
if len(b) < 4 {
return d, errors.Errorf("int4 requires 4 bytes for binary format")
}
i := int32(binary.BigEndian.Uint32(b))
d = parser.NewDInt(parser.DInt(i))
default:
return d, errors.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:
if len(b) < 8 {
return d, errors.Errorf("int8 requires 8 bytes for binary format")
}
i := int64(binary.BigEndian.Uint64(b))
d = parser.NewDInt(parser.DInt(i))
default:
return d, errors.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:
if len(b) < 4 {
return d, errors.Errorf("float4 requires 4 bytes for binary format")
}
f := math.Float32frombits(binary.BigEndian.Uint32(b))
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, errors.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:
if len(b) < 8 {
return d, errors.Errorf("float8 requires 8 bytes for binary format")
}
f := math.Float64frombits(binary.BigEndian.Uint64(b))
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, errors.Errorf("unsupported float8 format code: %d", code)
}
case oid.T_numeric:
switch code {
case formatText:
dd := &parser.DDecimal{}
if _, ok := dd.SetString(string(b)); !ok {
return nil, errors.Errorf("could not parse string %q as decimal", b)
}
d = dd
case formatBinary:
r := bytes.NewReader(b)
alloc := struct {
pgNum pgNumeric
i16 int16
dd parser.DDecimal
}{}
for _, ptr := range []interface{}{
&alloc.pgNum.ndigits,
&alloc.pgNum.weight,
&alloc.pgNum.sign,
&alloc.pgNum.dscale,
} {
if err := binary.Read(r, binary.BigEndian, ptr); err != nil {
return d, err
}
}
if alloc.pgNum.ndigits > 0 {
decDigits := make([]byte, 0, alloc.pgNum.ndigits*pgDecDigits)
nextDigit := func() error {
if err := binary.Read(r, binary.BigEndian, &alloc.i16); err != nil {
return err
}
numZeroes := pgDecDigits
for i16 := alloc.i16; i16 > 0; i16 /= 10 {
numZeroes--
}
for ; numZeroes > 0; numZeroes-- {
decDigits = append(decDigits, '0')
}
return nil
}
for i := int16(0); i < alloc.pgNum.ndigits-1; i++ {
if err := nextDigit(); err != nil {
return d, err
}
if alloc.i16 > 0 {
decDigits = strconv.AppendUint(decDigits, uint64(alloc.i16), 10)
}
}
// The last digit may contain padding, which we need to deal with.
if err := nextDigit(); err != nil {
return d, err
}
dscale := (alloc.pgNum.ndigits - (alloc.pgNum.weight + 1)) * pgDecDigits
if overScale := dscale - alloc.pgNum.dscale; overScale > 0 {
dscale -= overScale
for i := int16(0); i < overScale; i++ {
alloc.i16 /= 10
}
}
decDigits = strconv.AppendUint(decDigits, uint64(alloc.i16), 10)
decString := string(decDigits)
if _, ok := alloc.dd.UnscaledBig().SetString(decString, 10); !ok {
return nil, errors.Errorf("could not parse string %q as decimal", decString)
}
alloc.dd.SetScale(inf.Scale(dscale))
}
switch alloc.pgNum.sign {
case pgNumericPos:
case pgNumericNeg:
alloc.dd.Neg(&alloc.dd.Dec)
default:
return d, errors.Errorf("unsupported numeric sign: %d", alloc.pgNum.sign)
}
d = &alloc.dd
default:
return d, errors.Errorf("unsupported numeric format code: %d", code)
}
case oid.T_text, oid.T_varchar:
switch code {
case formatText, formatBinary:
d = parser.NewDString(string(b))
default:
return d, errors.Errorf("unsupported text format code: %d", code)
}
case oid.T_bytea:
switch code {
case formatText:
// http://www.postgresql.org/docs/current/static/datatype-binary.html#AEN5667
// Code cribbed from github.com/lib/pq.
// We only support hex encoding.
if len(b) >= 2 && bytes.Equal(b[:2], []byte("\\x")) {
b = b[2:] // trim off leading "\\x"
result := make([]byte, hex.DecodedLen(len(b)))
_, err := hex.Decode(result, b)
if err != nil {
return d, err
}
d = parser.NewDBytes(parser.DBytes(result))
} else {
return d, errors.Errorf("unsupported bytea encoding: %q", b)
}
case formatBinary:
d = parser.NewDBytes(parser.DBytes(b))
default:
return d, errors.Errorf("unsupported bytea format code: %d", code)
}
case oid.T_timestamp:
switch code {
case formatText:
ts, err := parseTs(string(b))
if err != nil {
return d, errors.Errorf("could not parse string %q as timestamp", b)
}
d = parser.MakeDTimestamp(ts, time.Microsecond)
case formatBinary:
if len(b) < 8 {
return d, errors.Errorf("timestamp requires 8 bytes for binary format")
}
i := int64(binary.BigEndian.Uint64(b))
d = parser.MakeDTimestamp(pgBinaryToTime(i), time.Microsecond)
default:
return d, errors.Errorf("unsupported timestamp format code: %d", code)
}
case oid.T_timestamptz:
switch code {
case formatText:
ts, err := parseTs(string(b))
if err != nil {
return d, errors.Errorf("could not parse string %q as timestamp", b)
}
d = parser.MakeDTimestampTZ(ts, time.Microsecond)
case formatBinary:
if len(b) < 8 {
return d, errors.Errorf("timestamptz requires 8 bytes for binary format")
}
i := int64(binary.BigEndian.Uint64(b))
d = parser.MakeDTimestampTZ(pgBinaryToTime(i), time.Microsecond)
default:
return d, errors.Errorf("unsupported timestamptz format code: %d", code)
}
case oid.T_date:
switch code {
case formatText:
ts, err := parseTs(string(b))
if err != nil {
res, err := parser.ParseDDate(string(b), time.UTC)
if err != nil {
return d, errors.Errorf("could not parse string %q as date", b)
}
d = res
} else {
daysSinceEpoch := ts.Unix() / secondsInDay
d = parser.NewDDate(parser.DDate(daysSinceEpoch))
}
case formatBinary:
if len(b) < 4 {
return d, errors.Errorf("date requires 4 bytes for binary format")
}
i := int32(binary.BigEndian.Uint32(b))
d = pgBinaryToDate(i)
default:
return d, errors.Errorf("unsupported date format code: %d", code)
}
case oid.T_interval:
switch code {
case formatText:
d, err := parser.ParseDInterval(string(b))
if err != nil {
return d, errors.Errorf("could not parse string %q as interval", b)
}
return d, nil
default:
return d, errors.Errorf("unsupported interval format code: %d", code)
}
default:
return d, errors.Errorf("unsupported OID: %v", id)
}
return d, nil
}
func typByVal(typ parser.Type) parser.Datum {
_, variable := typ.Size()
return parser.MakeDBool(parser.DBool(!variable))
}
// Test that distributing agg functions according to DistAggregationTable
// yields correct results. We're going to run each aggregation as either the
// two-stage process described by the DistAggregationTable or as a single global
// process, and verify that the results are the same.
func TestDistAggregationTable(t *testing.T) {
defer leaktest.AfterTest(t)()
const numRows = 100
tc := serverutils.StartTestCluster(t, 1, base.TestClusterArgs{})
defer tc.Stopper().Stop()
// Create a table with a few columns:
// - random integer values from 0 to numRows
// - random integer values (with some NULLs)
// - random bool value (mostly false)
// - random bool value (mostly true)
// - random decimals
// - random decimals (with some NULLs)
rng, _ := randutil.NewPseudoRand()
sqlutils.CreateTable(
t, tc.ServerConn(0), "t",
"k INT PRIMARY KEY, int1 INT, int2 INT, bool1 BOOL, bool2 BOOL, dec1 DECIMAL, dec2 DECIMAL",
numRows,
func(row int) []parser.Datum {
return []parser.Datum{
parser.NewDInt(parser.DInt(row)),
parser.NewDInt(parser.DInt(rng.Intn(numRows))),
sqlbase.RandDatum(rng, sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT}, true),
parser.MakeDBool(parser.DBool(rng.Intn(10) == 0)),
parser.MakeDBool(parser.DBool(rng.Intn(10) != 0)),
sqlbase.RandDatum(rng, sqlbase.ColumnType{Kind: sqlbase.ColumnType_DECIMAL}, false),
sqlbase.RandDatum(rng, sqlbase.ColumnType{Kind: sqlbase.ColumnType_DECIMAL}, true),
}
},
)
kvDB := tc.Server(0).KVClient().(*client.DB)
desc := sqlbase.GetTableDescriptor(kvDB, "test", "t")
for fn, info := range DistAggregationTable {
if info.LocalStage == distsqlrun.AggregatorSpec_IDENT &&
info.FinalStage == distsqlrun.AggregatorSpec_IDENT {
// IDENT only works as expected if all rows have the same value on the
// relevant column; skip testing this trivial case.
continue
}
// We're going to test each aggregation function on every column that can be
// used as input for it.
foundCol := false
for colIdx := 1; colIdx < len(desc.Columns); colIdx++ {
// See if this column works with this function.
_, _, err := distsqlrun.GetAggregateInfo(fn, desc.Columns[colIdx].Type)
if err != nil {
continue
}
foundCol = true
for _, numRows := range []int{5, numRows / 10, numRows / 2, numRows} {
name := fmt.Sprintf("%s/%s/%d", fn, desc.Columns[colIdx].Name, numRows)
t.Run(name, func(t *testing.T) {
checkDistAggregationInfo(t, tc.Server(0), desc, colIdx, numRows, fn, info)
})
}
}
if !foundCol {
t.Errorf("aggregation function %s was not tested (no suitable column)", fn)
}
}
}
// splitBoolExpr splits a boolean expression E into two boolean expressions RES and REM such that:
//
// - RES only has variables known to the conversion function (it is "restricted" to a particular
// set of variables)
//
// - If weaker is true, for any setting of variables x:
// E(x) = (RES(x) AND REM(x))
// This implies RES(x) <= E(x), i.e. RES is "weaker"
//
// - If weaker is false:
// E(x) = (RES(x) OR REM(x))
// This implies RES(x) => E(x), i.e. RES is "stronger"
func splitBoolExpr(
expr parser.TypedExpr, conv varConvertFunc, weaker bool,
) (restricted, remainder parser.TypedExpr) {
// If the expression only contains "restricted" vars, the split is trivial.
if exprCheckVars(expr, conv) {
// An "empty" filter is always true in the weaker (normal) case (where the filter is
// equivalent to RES AND REM) and always false in the stronger (inverted) case (where the
// filter is equivalent to RES OR REM).
return exprConvertVars(expr, conv), parser.MakeDBool(parser.DBool(weaker))
}
switch t := expr.(type) {
case *parser.AndExpr:
if weaker {
// In the weaker (normal) case, we have
// E = (leftRes AND leftRem) AND (rightRes AND rightRem)
// We can just rearrange:
// E = (leftRes AND rightRes) AND (leftRem AND rightRem)
leftRes, leftRem := splitBoolExpr(t.TypedLeft(), conv, weaker)
rightRes, rightRem := splitBoolExpr(t.TypedRight(), conv, weaker)
return makeAnd(leftRes, rightRes), makeAnd(leftRem, rightRem)
}
// In the stronger (inverted) case, we have
// E = (leftRes OR leftRem) AND (rightRes OR rightRem)
// We can't do more than:
// E = (leftRes AND rightRes) OR E
leftRes, _ := splitBoolExpr(t.TypedLeft(), conv, weaker)
rightRes, _ := splitBoolExpr(t.TypedRight(), conv, weaker)
return makeAnd(leftRes, rightRes), expr
case *parser.OrExpr:
if !weaker {
// In the stronger (inverted) case, we have
// E = (leftRes OR leftRem) OR (rightRes AND rightRem)
// We can just rearrange:
// E = (leftRes OR rightRes) OR (leftRem AND rightRem)
leftRes, leftRem := splitBoolExpr(t.TypedLeft(), conv, weaker)
rightRes, rightRem := splitBoolExpr(t.TypedRight(), conv, weaker)
return makeOr(leftRes, rightRes), makeOr(leftRem, rightRem)
}
// In the weaker (normal) case, we have
// E = (leftRes AND leftRem) OR (rightRes AND rightRem)
// We can't do more than:
// E = (leftRes OR rightRes) OR E
leftRes, _ := splitBoolExpr(t.TypedLeft(), conv, weaker)
rightRes, _ := splitBoolExpr(t.TypedRight(), conv, weaker)
return makeOr(leftRes, rightRes), expr
case *parser.ParenExpr:
return splitBoolExpr(t.TypedInnerExpr(), conv, weaker)
case *parser.NotExpr:
exprRes, exprRem := splitBoolExpr(t.TypedInnerExpr(), conv, !weaker)
return makeNot(exprRes), makeNot(exprRem)
default:
// We can't split off anything (we already handled the case when expr contains only
// restricted vars above).
// For why we return DBool(weaker), see the comment above on "empty" filters.
return parser.MakeDBool(parser.DBool(weaker)), expr
}
}
func simplifyOneAndInExpr(left, right *parser.ComparisonExpr) (parser.TypedExpr, parser.TypedExpr) {
if left.Operator != parser.In && right.Operator != parser.In {
panic(fmt.Sprintf("IN expression required: %s vs %s", left, right))
}
origLeft, origRight := left, right
switch left.Operator {
case parser.EQ, parser.NE, parser.GT, parser.GE, parser.LT, parser.LE, parser.Is:
switch right.Operator {
case parser.In:
left, right = right, left
}
fallthrough
case parser.In:
ltuple := *left.Right.(*parser.DTuple)
switch right.Operator {
case parser.Is:
if right.Right == parser.DNull {
return parser.MakeDBool(false), nil
}
case parser.EQ, parser.NE, parser.GT, parser.GE, parser.LT, parser.LE:
// Our tuple will be sorted (see simplifyComparisonExpr). Binary search
// for the right datum.
datum := right.Right.(parser.Datum)
i := sort.Search(len(ltuple), func(i int) bool {
return ltuple[i].(parser.Datum).Compare(datum) >= 0
})
switch right.Operator {
case parser.EQ:
if i < len(ltuple) && ltuple[i].Compare(datum) == 0 {
return right, nil
}
return parser.MakeDBool(false), nil
case parser.NE:
if i < len(ltuple) && ltuple[i].Compare(datum) == 0 {
if len(ltuple) < 2 {
return parser.MakeDBool(false), nil
}
ltuple = remove(ltuple, i)
}
return parser.NewTypedComparisonExpr(
parser.In,
left.TypedLeft(),
<uple,
), nil
case parser.GT:
if i < len(ltuple) {
if ltuple[i].Compare(datum) == 0 {
ltuple = ltuple[i+1:]
} else {
ltuple = ltuple[i:]
}
if len(ltuple) > 0 {
return parser.NewTypedComparisonExpr(
parser.In,
left.TypedLeft(),
<uple,
), nil
}
}
return parser.MakeDBool(false), nil
case parser.GE:
if i < len(ltuple) {
ltuple = ltuple[i:]
if len(ltuple) > 0 {
return parser.NewTypedComparisonExpr(
parser.In,
left.TypedLeft(),
<uple,
), nil
}
}
return parser.MakeDBool(false), nil
case parser.LT:
if i < len(ltuple) {
if i == 0 {
return parser.MakeDBool(false), nil
}
ltuple = ltuple[:i]
return parser.NewTypedComparisonExpr(
parser.In,
left.TypedLeft(),
<uple,
), nil
}
return left, nil
case parser.LE:
if i < len(ltuple) {
if ltuple[i].Compare(datum) == 0 {
i++
}
if i == 0 {
return parser.MakeDBool(false), nil
}
ltuple = ltuple[:i]
return parser.NewTypedComparisonExpr(
parser.In,
left.TypedLeft(),
<uple,
), nil
}
return left, nil
}
case parser.In:
// Both of our tuples are sorted. Intersect the lists.
rtuple := *right.Right.(*parser.DTuple)
intersection := intersectSorted(ltuple, rtuple)
if len(*intersection) == 0 {
return parser.MakeDBool(false), nil
}
return parser.NewTypedComparisonExpr(
parser.In,
left.TypedLeft(),
intersection,
), nil
}
}
return origLeft, origRight
}
// UnmarshalColumnValue decodes the value from a key-value pair using the type
// expected by the column. An error is returned if the value's type does not
// match the column's type.
func UnmarshalColumnValue(
a *DatumAlloc, kind ColumnType_Kind, value *roachpb.Value,
) (parser.Datum, error) {
if value == nil {
return parser.DNull, nil
}
switch kind {
case ColumnType_BOOL:
v, err := value.GetBool()
if err != nil {
return nil, err
}
return parser.MakeDBool(parser.DBool(v)), nil
case ColumnType_INT:
v, err := value.GetInt()
if err != nil {
return nil, err
}
return a.NewDInt(parser.DInt(v)), nil
case ColumnType_FLOAT:
v, err := value.GetFloat()
if err != nil {
return nil, err
}
return a.NewDFloat(parser.DFloat(v)), nil
case ColumnType_DECIMAL:
v, err := value.GetDecimal()
if err != nil {
return nil, err
}
dd := a.NewDDecimal(parser.DDecimal{})
dd.Set(v)
return dd, nil
case ColumnType_STRING:
v, err := value.GetBytes()
if err != nil {
return nil, err
}
return a.NewDString(parser.DString(v)), nil
case ColumnType_BYTES:
v, err := value.GetBytes()
if err != nil {
return nil, err
}
return a.NewDBytes(parser.DBytes(v)), nil
case ColumnType_DATE:
v, err := value.GetInt()
if err != nil {
return nil, err
}
return a.NewDDate(parser.DDate(v)), nil
case ColumnType_TIMESTAMP:
v, err := value.GetTime()
if err != nil {
return nil, err
}
return a.NewDTimestamp(parser.DTimestamp{Time: v}), nil
case ColumnType_TIMESTAMPTZ:
v, err := value.GetTime()
if err != nil {
return nil, err
}
return a.NewDTimestampTZ(parser.DTimestampTZ{Time: v}), nil
case ColumnType_INTERVAL:
d, err := value.GetDuration()
if err != nil {
return nil, err
}
return a.NewDInterval(parser.DInterval{Duration: d}), nil
default:
return nil, errors.Errorf("unsupported column type: %s", kind)
}
}
// 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
}
columns := ResultColumns{
{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},
}
return &delayedNode{
p: p,
name: "SHOW INDEX FROM " + tn.String(),
columns: columns,
constructor: func(p *planner) (planNode, error) {
v := p.newContainerValuesNode(columns, 0)
appendRow := func(index sqlbase.IndexDescriptor, colName string, sequence int,
direction string, isStored bool) error {
newRow := parser.DTuple{
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)),
}
_, err := v.rows.AddRow(newRow)
return err
}
for _, index := range append([]sqlbase.IndexDescriptor{desc.PrimaryIndex}, desc.Indexes...) {
sequence := 1
for i, col := range index.ColumnNames {
if err := appendRow(index, col, sequence, index.ColumnDirections[i].String(), false); err != nil {
v.rows.Close()
return nil, err
}
sequence++
}
for _, col := range index.StoreColumnNames {
if err := appendRow(index, col, sequence, "N/A", true); err != nil {
v.rows.Close()
return nil, err
}
sequence++
}
}
return v, nil
},
}, nil
}
// DecodeTableKey decodes a table key/value.
func DecodeTableKey(
a *DatumAlloc, valType parser.Type, key []byte, dir encoding.Direction,
) (parser.Datum, []byte, error) {
if (dir != encoding.Ascending) && (dir != encoding.Descending) {
return nil, nil, errors.Errorf("invalid direction: %d", dir)
}
var isNull bool
if key, isNull = encoding.DecodeIfNull(key); isNull {
return parser.DNull, key, nil
}
var rkey []byte
var err error
switch valType {
case parser.TypeBool:
var i int64
if dir == encoding.Ascending {
rkey, i, err = encoding.DecodeVarintAscending(key)
} else {
rkey, i, err = encoding.DecodeVarintDescending(key)
}
// No need to chunk allocate DBool as MakeDBool returns either
// parser.DBoolTrue or parser.DBoolFalse.
return parser.MakeDBool(parser.DBool(i != 0)), rkey, err
case parser.TypeInt:
var i int64
if dir == encoding.Ascending {
rkey, i, err = encoding.DecodeVarintAscending(key)
} else {
rkey, i, err = encoding.DecodeVarintDescending(key)
}
return a.NewDInt(parser.DInt(i)), rkey, err
case parser.TypeFloat:
var f float64
if dir == encoding.Ascending {
rkey, f, err = encoding.DecodeFloatAscending(key)
} else {
rkey, f, err = encoding.DecodeFloatDescending(key)
}
return a.NewDFloat(parser.DFloat(f)), rkey, err
case parser.TypeDecimal:
var d *inf.Dec
if dir == encoding.Ascending {
rkey, d, err = encoding.DecodeDecimalAscending(key, nil)
} else {
rkey, d, err = encoding.DecodeDecimalDescending(key, nil)
}
dd := a.NewDDecimal(parser.DDecimal{})
dd.Set(d)
return dd, rkey, err
case parser.TypeString:
var r string
if dir == encoding.Ascending {
rkey, r, err = encoding.DecodeUnsafeStringAscending(key, nil)
} else {
rkey, r, err = encoding.DecodeUnsafeStringDescending(key, nil)
}
return a.NewDString(parser.DString(r)), rkey, err
case parser.TypeBytes:
var r []byte
if dir == encoding.Ascending {
rkey, r, err = encoding.DecodeBytesAscending(key, nil)
} else {
rkey, r, err = encoding.DecodeBytesDescending(key, nil)
}
return a.NewDBytes(parser.DBytes(r)), rkey, err
case parser.TypeDate:
var t int64
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeVarintAscending(key)
} else {
rkey, t, err = encoding.DecodeVarintDescending(key)
}
return a.NewDDate(parser.DDate(t)), rkey, err
case parser.TypeTimestamp:
var t time.Time
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeTimeAscending(key)
} else {
rkey, t, err = encoding.DecodeTimeDescending(key)
}
return a.NewDTimestamp(parser.DTimestamp{Time: t}), rkey, err
case parser.TypeTimestampTZ:
var t time.Time
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeTimeAscending(key)
} else {
rkey, t, err = encoding.DecodeTimeDescending(key)
}
return a.NewDTimestampTZ(parser.DTimestampTZ{Time: t}), rkey, err
case parser.TypeInterval:
var d duration.Duration
if dir == encoding.Ascending {
rkey, d, err = encoding.DecodeDurationAscending(key)
} else {
rkey, d, err = encoding.DecodeDurationDescending(key)
}
return a.NewDInterval(parser.DInterval{Duration: d}), rkey, err
default:
return nil, nil, errors.Errorf("TODO(pmattis): decoded index key: %s", valType)
}
}