// parsePkTuple parese one pk tuple.
func parsePkTuple(tokenizer *sqlparser.Tokenizer) (tuple sqlparser.ValTuple, err error) {
// start scanning the list
for typ, val := tokenizer.Scan(); typ != ')'; typ, val = tokenizer.Scan() {
switch typ {
case '-':
// handle negative numbers
typ2, val2 := tokenizer.Scan()
if typ2 != sqlparser.NUMBER {
return nil, fmt.Errorf("expecing number after '-'")
}
num := append(sqlparser.NumVal("-"), val2...)
tuple = append(tuple, num)
case sqlparser.NUMBER:
tuple = append(tuple, sqlparser.NumVal(val))
case sqlparser.NULL:
tuple = append(tuple, new(sqlparser.NullVal))
case sqlparser.STRING:
decoded := make([]byte, base64.StdEncoding.DecodedLen(len(val)))
numDecoded, err := base64.StdEncoding.Decode(decoded, val)
if err != nil {
return nil, err
}
tuple = append(tuple, sqlparser.StrVal(decoded[:numDecoded]))
default:
return nil, fmt.Errorf("syntax error at position: %d", tokenizer.Position)
}
}
return tuple, nil
}
// getWhereClause returns a whereClause based on desired upper and lower
// bounds for primary key.
func (qs *QuerySplitter) getWhereClause(start, end sqltypes.Value) *sqlparser.Where {
var startClause *sqlparser.ComparisonExpr
var endClause *sqlparser.ComparisonExpr
var clauses sqlparser.BoolExpr
// No upper or lower bound, just return the where clause of original query
if start.IsNull() && end.IsNull() {
return qs.sel.Where
}
pk := &sqlparser.ColName{
Name: []byte(qs.pkCol),
}
// pkCol >= start
if !start.IsNull() {
startClause = &sqlparser.ComparisonExpr{
Operator: sqlparser.AST_GE,
Left: pk,
Right: sqlparser.NumVal((start).Raw()),
}
}
// pkCol < end
if !end.IsNull() {
endClause = &sqlparser.ComparisonExpr{
Operator: sqlparser.AST_LT,
Left: pk,
Right: sqlparser.NumVal((end).Raw()),
}
}
if startClause == nil {
clauses = endClause
} else {
if endClause == nil {
clauses = startClause
} else {
// pkCol >= start AND pkCol < end
clauses = &sqlparser.AndExpr{
Left: startClause,
Right: endClause,
}
}
}
if qs.sel.Where != nil {
clauses = &sqlparser.AndExpr{
Left: qs.sel.Where.Expr,
Right: clauses,
}
}
return &sqlparser.Where{
Type: sqlparser.AST_WHERE,
Expr: clauses,
}
}