// CastValue casts a value based on column type.
func CastValue(ctx context.Context, val types.Datum, col *Column) (casted types.Datum, err error) {
casted, err = val.ConvertTo(&col.FieldType)
if err != nil {
if variable.GetSessionVars(ctx).StrictSQLMode {
return casted, errors.Trace(err)
}
// TODO: add warnings.
log.Warnf("cast value error %v", err)
}
return casted, nil
}
func convertToDuration(sc *variable.StatementContext, arg types.Datum, fsp int) (d types.Datum, err error) {
f := types.NewFieldType(mysql.TypeDuration)
f.Decimal = fsp
d, err = arg.ConvertTo(sc, f)
if err != nil {
d.SetNull()
return d, errors.Trace(err)
}
if d.IsNull() {
return d, nil
}
if d.Kind() != types.KindMysqlDuration {
d.SetNull()
return d, errors.Errorf("need duration type, but got %T", d.GetValue())
}
return d, nil
}
func convertToTime(sc *variable.StatementContext, arg types.Datum, tp byte) (d types.Datum, err error) {
f := types.NewFieldType(tp)
f.Decimal = types.MaxFsp
d, err = arg.ConvertTo(sc, f)
if err != nil {
d.SetNull()
return d, errors.Trace(err)
}
if d.IsNull() {
return d, nil
}
if d.Kind() != types.KindMysqlTime {
d.SetNull()
return d, errors.Errorf("need time type, but got %T", d.GetValue())
}
return d, nil
}
func convertToTime(arg types.Datum, tp byte) (d types.Datum, err error) {
f := types.NewFieldType(tp)
f.Decimal = mysql.MaxFsp
d, err = arg.ConvertTo(f)
if err != nil {
d.SetNull()
return d, errors.Trace(err)
}
if d.Kind() == types.KindNull {
return d, nil
}
if d.Kind() != types.KindMysqlTime {
err = errors.Errorf("need time type, but got %T", d.GetValue())
d.SetNull()
return d, err
}
return d, nil
}
func convertToDuration(arg types.Datum, fsp int) (d types.Datum, err error) {
f := types.NewFieldType(mysql.TypeDuration)
f.Decimal = fsp
d, err = arg.ConvertTo(f)
if err != nil {
d.SetNull()
return d, errors.Trace(err)
}
if d.Kind() == types.KindNull {
d.SetNull()
return d, nil
}
if d.Kind() != types.KindMysqlDuration {
err = errors.Errorf("need duration type, but got %T", d.GetValue())
d.SetNull()
return d, err
}
return d, nil
}
// AddRecord implements table.Table AddRecord interface.
func (t *Table) AddRecord(ctx context.Context, r []types.Datum) (recordID int64, err error) {
var hasRecordID bool
for _, col := range t.Cols() {
if col.IsPKHandleColumn(t.meta) {
recordID = r[col.Offset].GetInt64()
hasRecordID = true
break
}
}
if !hasRecordID {
recordID, err = t.alloc.Alloc(t.ID)
if err != nil {
return 0, errors.Trace(err)
}
}
txn, err := ctx.GetTxn(false)
if err != nil {
return 0, errors.Trace(err)
}
bs := kv.NewBufferStore(txn)
defer bs.Release()
// Insert new entries into indices.
h, err := t.addIndices(ctx, recordID, r, bs)
if err != nil {
return h, errors.Trace(err)
}
if err = t.LockRow(ctx, recordID, false); err != nil {
return 0, errors.Trace(err)
}
// Set public and write only column value.
for _, col := range t.writableCols() {
if col.IsPKHandleColumn(t.meta) {
continue
}
var value types.Datum
if col.State == model.StateWriteOnly || col.State == model.StateWriteReorganization {
// if col is in write only or write reorganization state, we must add it with its default value.
value, _, err = table.GetColDefaultValue(ctx, &col.ColumnInfo)
if err != nil {
return 0, errors.Trace(err)
}
value, err = value.ConvertTo(&col.FieldType)
if err != nil {
return 0, errors.Trace(err)
}
} else {
value = r[col.Offset]
}
key := t.RecordKey(recordID, col)
err = SetColValue(txn, key, value)
if err != nil {
return 0, errors.Trace(err)
}
}
if err = bs.SaveTo(txn); err != nil {
return 0, errors.Trace(err)
}
variable.GetSessionVars(ctx).AddAffectedRows(1)
return recordID, nil
}