path: root/core/vm/sqlvm/schema/schema.go

package schema

import (
    "errors"
    "io"

    "github.com/shopspring/decimal"

    "github.com/dexon-foundation/dexon/common"
    "github.com/dexon-foundation/dexon/core/vm/sqlvm/ast"
    se "github.com/dexon-foundation/dexon/core/vm/sqlvm/errors"
    "github.com/dexon-foundation/dexon/rlp"
)

// Error defines for encode and decode.
var (
    ErrEncodeUnexpectedType = errors.New("encode unexpected type")
    ErrDecodeUnexpectedType = errors.New("decode unexpected type")
)

// ColumnAttr defines bit flags for describing column attribute.
type ColumnAttr uint16

const (
    // ColumnAttrPrimaryKey is a no-op. Primary key constraints are converted
    // to a unique index during contract creation.
    ColumnAttrPrimaryKey ColumnAttr = 1 << iota
    // ColumnAttrNotNull is a no-op. We have not supported NULL values so all
    // columns are implicitly non-null.
    ColumnAttrNotNull
    // ColumnAttrUnique is a no-op. Unique constraints are converted to unique
    // indices during contract creation.
    ColumnAttrUnique
    // ColumnAttrHasDefault indicates whether a column has a default value. The
    // default value does not affect the starting value of AUTOINCREMENT.
    ColumnAttrHasDefault
    // ColumnAttrHasForeignKey indicates whether a column references a column
    // on a different table.
    ColumnAttrHasForeignKey
    // ColumnAttrHasSequence indicates whether a column is declared with
    // AUTOINCREMENT. It is only valid on integer fields.
    ColumnAttrHasSequence
)

// GetDeclaredFlags returns flags which can be mapped to the source code tokens.
func (a ColumnAttr) GetDeclaredFlags() ColumnAttr {
    mask := ColumnAttrPrimaryKey |
        ColumnAttrNotNull |
        ColumnAttrUnique |
        ColumnAttrHasDefault |
        ColumnAttrHasForeignKey |
        ColumnAttrHasSequence
    return a & mask

}

// GetDerivedFlags returns flags which are not declared in the source code but
// can be derived from it.
func (a ColumnAttr) GetDerivedFlags() ColumnAttr {
    mask := ColumnAttr(0)
    return a & mask
}

// FunctionRef defines the type for number of builtin function.
type FunctionRef uint16

// TableRef defines the type for table index in Schema.
type TableRef uint8

// ColumnRef defines the type for column index in Table.Columns.
type ColumnRef uint8

// IndexRef defines the type for array index of Column.Indices.
type IndexRef uint8

// SequenceRef defines the type for sequence index in Table.
type SequenceRef uint8

// SelectColumnRef defines the type for column index in SelectStmtNode.Column.
type SelectColumnRef uint16

// IndexAttr defines bit flags for describing index attribute.
type IndexAttr uint16

const (
    // IndexAttrUnique indicates whether an index is unique.
    IndexAttrUnique IndexAttr = 1 << iota
    // IndexAttrReferenced indicates whether an index is referenced by columns
    // with foreign key constraints. This attribute cannot be specified by
    // users. It is computed automatically during contract creation.
    IndexAttrReferenced
)

// GetDeclaredFlags returns flags which can be mapped to the source code tokens.
func (a IndexAttr) GetDeclaredFlags() IndexAttr {
    mask := IndexAttrUnique
    return a & mask
}

// GetDerivedFlags returns flags which are not declared in the source code but
// can be derived from it.
func (a IndexAttr) GetDerivedFlags() IndexAttr {
    mask := IndexAttrReferenced
    return a & mask
}

// Schema defines sqlvm schema struct.
type Schema []Table

// SetupColumnOffset set all tables' column offset.
func (s Schema) SetupColumnOffset() {
    for i := range s {
        s[i].SetupColumnOffset()
    }
}

// Table defiens sqlvm table struct.
type Table struct {
    Name    []byte
    Columns []Column
    Indices []Index
}

// GetFieldType return fields' data type.
func (t *Table) GetFieldType(fields []uint8) ([]ast.DataType, error) {
    types := make([]ast.DataType, len(fields))
    columns := t.Columns
    for i, f := range fields {
        if int(f) >= len(columns) {
            return nil, se.ErrorCodeIndexOutOfRange
        }
        types[i] = columns[f].Type
    }
    return types, nil
}

// SetupColumnOffset set columns' slot and byte offset.
func (t *Table) SetupColumnOffset() {
    slotOffset := uint8(0)
    byteOffset := uint8(0)
    for i, col := range t.Columns {
        size := col.Type.Size()
        if size+byteOffset > common.HashLength {
            slotOffset++
            byteOffset = 0
        }
        t.Columns[i].SlotOffset = slotOffset
        t.Columns[i].ByteOffset = byteOffset
        byteOffset += size
    }
}

// Index defines sqlvm index struct.
type Index struct {
    Name    []byte
    Attr    IndexAttr
    Columns []ColumnRef // Columns must be sorted in ascending order.
}

type column struct {
    Name        []byte
    Type        ast.DataType
    Attr        ColumnAttr
    ForeignKeys []ColumnDescriptor
    Sequence    SequenceRef
    SlotOffset  uint8
    ByteOffset  uint8
    // Rest is a special field reserved for use in EncodeRLP. The value stored
    // in it will be overwritten every time EncodeRLP is called.
    Rest interface{}
}

// Column defines sqlvm index struct.
type Column struct {
    column
    Default interface{} // decimal.Decimal, bool, []byte
}

// NewColumn return a Column instance.
func NewColumn(Name []byte, Type ast.DataType, Attr ColumnAttr,
    ForeignKeys []ColumnDescriptor, Sequence SequenceRef) Column {
    c := column{
        Name:        Name,
        Type:        Type,
        Attr:        Attr,
        ForeignKeys: ForeignKeys,
        Sequence:    Sequence,
    }

    return Column{
        column: c,
    }
}

var _ rlp.Decoder = (*Column)(nil)
var _ rlp.Encoder = Column{}

// EncodeRLP encodes column with rlp encode.
func (c Column) EncodeRLP(w io.Writer) error {
    if c.Default != nil {
        switch d := c.Default.(type) {
        case bool:
            v := byte(0)
            if d {
                v = byte(1)
            }
            c.Rest = []byte{v}
        case []byte:
            c.Rest = d
        case decimal.Decimal:
            var err error
            c.Rest, err = ast.DecimalEncode(c.Type, d)
            if err != nil {
                return err
            }
        default:
            return ErrEncodeUnexpectedType
        }
    } else {
        c.Rest = nil
    }

    return rlp.Encode(w, c.column)
}

// DecodeRLP decodes column with rlp decode.
func (c *Column) DecodeRLP(s *rlp.Stream) error {
    defer func() { c.Rest = nil }()

    err := s.Decode(&c.column)
    if err != nil {
        return err
    }

    switch rest := c.Rest.(type) {
    case []interface{}:
        // nil is converted to empty list by encoder, while empty list is
        // converted to []interface{} by decoder.
        // So we view this case as nil and skip it.
    case []byte:
        major, _ := ast.DecomposeDataType(c.Type)
        switch major {
        case ast.DataTypeMajorBool:
            if rest[0] == 1 {
                c.Default = true
            } else {
                c.Default = false
            }
        case ast.DataTypeMajorFixedBytes, ast.DataTypeMajorDynamicBytes:
            c.Default = rest
        default:
            d, err := ast.DecimalDecode(c.Type, rest)
            if err != nil {
                return err
            }
            c.Default = d
        }
    default:
        return ErrDecodeUnexpectedType
    }

    return nil
}

// FunctionDescriptor identifies a function.
type FunctionDescriptor struct {
    Function FunctionRef
}

var _ ast.IdentifierDescriptor = (*FunctionDescriptor)(nil)

// GetDescriptor is a useless function to satisfy the interface.
func (d FunctionDescriptor) GetDescriptor() uint32 {
    return uint32(0)<<24 | uint32(d.Function)<<8
}

// TableDescriptor identifies a table in a schema by an array index.
type TableDescriptor struct {
    Table TableRef
}

var _ ast.IdentifierDescriptor = (*TableDescriptor)(nil)

// GetDescriptor is a useless function to satisfy the interface.
func (d TableDescriptor) GetDescriptor() uint32 {
    return uint32(1)<<24 | uint32(d.Table)<<16
}

// ColumnDescriptor identifies a column in a schema by array indices.
type ColumnDescriptor struct {
    Table  TableRef
    Column ColumnRef
}

var _ ast.IdentifierDescriptor = (*ColumnDescriptor)(nil)

// GetDescriptor is a useless function to satisfy the interface.
func (d ColumnDescriptor) GetDescriptor() uint32 {
    return uint32(2)<<24 | uint32(d.Table)<<16 | uint32(d.Column)<<8
}

// IndexDescriptor identifies a index in a schema by array indices.
type IndexDescriptor struct {
    Table TableRef
    Index IndexRef
}

var _ ast.IdentifierDescriptor = (*IndexDescriptor)(nil)

// GetDescriptor is a useless function to satisfy the interface.
func (d IndexDescriptor) GetDescriptor() uint32 {
    return uint32(3)<<24 | uint32(d.Table)<<16 | uint32(d.Index)<<8
}

// SelectColumnDescriptor identifies a column specified in a select command by
// an array index.
type SelectColumnDescriptor struct {
    SelectColumn SelectColumnRef
}

var _ ast.IdentifierDescriptor = (*SelectColumnDescriptor)(nil)

// GetDescriptor is a useless function to satisfy the interface.
func (d SelectColumnDescriptor) GetDescriptor() uint32 {
    return uint32(4)<<24 | uint32(d.SelectColumn)<<8
}