From 3e82873e391d34e4a319556cc840c5ce145d8558 Mon Sep 17 00:00:00 2001
From: Jhih-Ming Huang <jm.huang@cobinhood.com>
Date: Mon, 11 Feb 2019 15:24:39 +0800
Subject: core: vm: sqlvm: shared interfaces and params
After reconstructing commits, we move shared interfaces and params as
first runtime implementation. In this commit we define OP codes, runtime
flow and entrypoint, and basic operand structs and minor helper
components.
---
core/vm/sqlvm/common/context.go | 11 +++
core/vm/sqlvm/errors/errors.go | 14 ++++
core/vm/sqlvm/runtime/instructions.go | 63 ++++++++++++++++
core/vm/sqlvm/runtime/jumptable.go | 3 +
core/vm/sqlvm/runtime/opcodes.go | 135 ++++++++++++++++++++++++++++++++++
core/vm/sqlvm/runtime/runtime.go | 19 +++++
6 files changed, 245 insertions(+)
create mode 100644 core/vm/sqlvm/common/context.go
create mode 100644 core/vm/sqlvm/runtime/instructions.go
create mode 100644 core/vm/sqlvm/runtime/jumptable.go
create mode 100644 core/vm/sqlvm/runtime/opcodes.go
create mode 100644 core/vm/sqlvm/runtime/runtime.go
diff --git a/core/vm/sqlvm/common/context.go b/core/vm/sqlvm/common/context.go
new file mode 100644
index 000000000..7c4305e3e
--- /dev/null
+++ b/core/vm/sqlvm/common/context.go
@@ -0,0 +1,11 @@
+package common
+
+import "github.com/dexon-foundation/dexon/core/vm"
+
+// Context holds SQL VM required params.
+type Context struct {
+ vm.Context
+
+ StateDB vm.StateDB
+ Contract *vm.Contract
+}
diff --git a/core/vm/sqlvm/errors/errors.go b/core/vm/sqlvm/errors/errors.go
index 60dee909b..f6b91ebae 100644
--- a/core/vm/sqlvm/errors/errors.go
+++ b/core/vm/sqlvm/errors/errors.go
@@ -89,6 +89,13 @@ const (
ErrorCodeEscapeSequenceTooShort
ErrorCodeInvalidUnicodeCodePoint
ErrorCodeUnknownEscapeSequence
+ // Runtime Error
+ ErrorCodeInvalidDataType
+ ErrorCodeOverflow
+ ErrorCodeUnderflow
+ ErrorCodeIndexOutOfRange
+ ErrorCodeInvalidCastType
+ ErrorCodeDividedByZero
)
var errorCodeMap = [...]string{
@@ -101,6 +108,13 @@ var errorCodeMap = [...]string{
ErrorCodeEscapeSequenceTooShort: "escape sequence too short",
ErrorCodeInvalidUnicodeCodePoint: "invalid unicode code point",
ErrorCodeUnknownEscapeSequence: "unknown escape sequence",
+ // Runtime Error
+ ErrorCodeInvalidDataType: "invalid data type",
+ ErrorCodeOverflow: "overflow",
+ ErrorCodeUnderflow: "underflow",
+ ErrorCodeIndexOutOfRange: "index out of range",
+ ErrorCodeInvalidCastType: "invalid cast type",
+ ErrorCodeDividedByZero: "divide by zero",
}
func (c ErrorCode) Error() string {
diff --git a/core/vm/sqlvm/runtime/instructions.go b/core/vm/sqlvm/runtime/instructions.go
new file mode 100644
index 000000000..f642a2515
--- /dev/null
+++ b/core/vm/sqlvm/runtime/instructions.go
@@ -0,0 +1,63 @@
+package runtime
+
+import (
+ "fmt"
+ "math/big"
+ "strings"
+
+ "github.com/dexon-foundation/dexon/core/vm/sqlvm/ast"
+ "github.com/dexon-foundation/dexon/core/vm/sqlvm/common"
+)
+
+var tupleJoin = "|"
+
+// OpFunction type
+// data could be fields Fields, pattern []byte, order Orders
+type OpFunction func(ctx *common.Context, ops []*Operand, registers []*Operand, output int) error
+
+// Instruction represents single instruction with essential information
+// collection.
+type Instruction struct {
+ op OpCode
+ input []*Operand
+ output int
+}
+
+// Raw with embedded big.Int value or byte slice which represents the real value
+// of basic operand unit.
+type Raw struct {
+ MajorType ast.DataTypeMajor
+ MinorType ast.DataTypeMinor
+
+ // for not bytes
+ Value *big.Int
+ Max, Min *big.Int
+ // for bytes
+ Bytes []byte
+}
+
+func (r *Raw) String() string {
+ return fmt.Sprintf(
+ "MajorType: %v, MinorType: %v, Value: %v, Bytes: %v",
+ r.MajorType, r.MinorType, r.Value, r.Bytes)
+}
+
+// Tuple is collection of Raw.
+type Tuple []*Raw
+
+func (t Tuple) String() string {
+ rawStr := []string{}
+ for i := 0; i < len(t); i++ {
+ rawStr = append(rawStr, t[i].String())
+ }
+ return strings.Join(rawStr, tupleJoin)
+}
+
+// Operand would be array-based value associated with meta to describe type of
+// array element.
+type Operand struct {
+ IsImmediate bool
+ Meta []ast.DataType
+ Data []Tuple
+ RegisterIndex *int
+}
diff --git a/core/vm/sqlvm/runtime/jumptable.go b/core/vm/sqlvm/runtime/jumptable.go
new file mode 100644
index 000000000..13ffef361
--- /dev/null
+++ b/core/vm/sqlvm/runtime/jumptable.go
@@ -0,0 +1,3 @@
+package runtime
+
+var jumpTable = map[OpCode]OpFunction{}
diff --git a/core/vm/sqlvm/runtime/opcodes.go b/core/vm/sqlvm/runtime/opcodes.go
new file mode 100644
index 000000000..22628b28e
--- /dev/null
+++ b/core/vm/sqlvm/runtime/opcodes.go
@@ -0,0 +1,135 @@
+package runtime
+
+// OpCode type
+type OpCode byte
+
+// 0x10 range - arithmetic ops. (array-based)
+const (
+ ADD OpCode = iota + 0x10
+ // ADD(t1, t2) res
+ // res = t1 + t2 = [1, 2] + [2, 3] = [3, 5]
+ MUL
+ // MUL(t1, t2) res
+ // res = t1 * t2 = [1, 2] * [2, 3] = [2, 6]
+ SUB
+ // SUB(t1, t2) res
+ // res = t1 - t2 = [1, 2] - [2, 3] = [-1, -1]
+ DIV
+ // DIV(t1, t2) res
+ // res = t1 / t2 = [1, 2] / [2, 3] = [0, 0]
+ MOD
+ // MOD(t1, t2) res
+ // res = t1 % t2 = [1, 2] % [2, 3] = [1, 2]
+
+)
+
+// 0x20 range - comparison ops.
+const (
+ LT OpCode = iota + 0x20
+ // LT(t1, t2) res
+ // res = t1 < t2 = [1, 2] < [2, 3] = [true, true]
+ GT
+ // GT(t1, t2) res
+ // res = t1 > t2 = [1, 2] > [2, 3] = [false, false]
+ EQ
+ // EQ(t1, t2) res
+ // res = t1 == t2 = [1, 2] == [2, 3] = [false, false]
+ AND
+ // AND(t1, t2) res
+ // res = t1 && t2 = [true, true] && [true, false] = [true, false]
+ OR
+ // OR(t1, t2) res
+ // res = t1 || t2 = [false, false] || [true, false] = [true, false]
+ NOT
+ // NOT(t1) res
+ // res = !t1 = ![false, true] = [true, false]
+ UNION
+ // UNION(t1, t2) res
+ // res = t1 ∪ t2 = [1, 2] ∪ [2, 3] = [1, 2, 3]
+ INTXN
+ // INTXN(t1, t2) res
+ // res = t1 ∩ t2 = [1, 2] ∩ [2, 3] = [2]
+ LIKE
+ // LIKE(t1, pattern) res
+ // res = t1 like '%abc%' =
+ // ['_abc_', '123'] like '%abc%' = [true, false]
+)
+
+// 0x30 range - pk/index/field meta ops
+const (
+ REPEATPK OpCode = iota + 0x30
+ // REPEATPK(pk) res res = [id1, id2, id3, ...]
+ // REPEATPK([tables, table_id, primary]) = [1, 2, 3, 5, 6, 7, ...]
+ REPEATIDX
+ // Scan given index value(s)
+ // REPEATIDX(base, idxv) res res = [id2, id4, id5, id6]
+ // REPEATIDX(
+ // [tables, table_id, indices, name_idx],
+ // [val1, val3]
+ // ) = [5, 6, 7, 10, 11, ... ]
+ REPEATIDXV
+ // Get possible values from index value meta
+ // REPEATIDXV(idx) res res = [val1, val2, val3, ...]
+ // REPEATIDXV(
+ // [tables, table_id, indices, name_idx]
+ // ) = ["alice", "bob", "foo", "bar", ... ]
+)
+
+// 0x40 range - format/output ops
+const (
+ ZIP OpCode = iota + 0x40
+ // ZIP(tgr, new) = res
+ // ZIP([f1, f2, f3], [c1, c2, c3]) = [(f1, c1), (f2, c2), (f3, c3)]
+ // ZIP(
+ // [(f1, c1), (f2, c2), (f3, c3)],
+ // [(x1, (y1)), (x2, (y2)), (x3, (y3))]
+ // ) = [(f1, c1, x1, (y1)), (f2, c2, x2, (y2)), (f3, c3, x2, (y2))]
+ FIELD
+ // (src, fields) = res
+ // (
+ // [(r1f1, r1f2, r1f3), (r2f1, r2f2, r2f3),...], [2,3]
+ // ) = [(r1f2, r1f3), (r2f2, r2f3), ...]
+ SORT
+ // SORT(src, [(field, order, null order)] ) = res
+ // SORT(
+ // [(a1, a2, a3), (b1, a2, null), (a1, b2, null), ...],
+ // [(1, asc, null_first), (2, desc, null_last), (3, asc, null_last)]
+ // ) = [(a1, a2, a3), (a1, b2, null), (b1, a2, null), ...]
+ FILTER
+ // FILTER(src, cond) = res
+ // FILTER([1, 2, 3, 4, 5], [true, false, true, false, false]) = [1, 3]
+ CAST
+ // CAST(t1, types) t2
+)
+
+// 0x60 range - storage ops
+const (
+ STOREPK OpCode = iota + 0x60
+ // STOREPK(pk, [uint256, uint256, ...])
+ LOADPK
+ // LOADPK(pk) array array = [uint256, uint256, ...]
+ STORE
+ // STORE(base, ids, values, fields, idxes)
+ // STORE(
+ // [tables, table_id, primary],
+ // [],
+ // [field1, field2, [field3.1, field3.2]],
+ // []
+ // )
+ // STORE(
+ // [tables, table_id, primary],
+ // [1, 2],
+ // [updated_field1, updated_field2],
+ // [1, 2]
+ // )
+ LOAD
+ // LOAD(base, ids, fields) array
+ // LOAD(
+ // [tables, table_id, primary], [1], []
+ // ) = [(field1, field2, [field3.1, field3.2])]
+ // LOAD(
+ // [tables, table_id, primary, [1], [1,3]
+ // ) =[(field1, [field3.1, field3.2])］
+ DELETE
+ // DELETE(base, ids, idxes)
+)
diff --git a/core/vm/sqlvm/runtime/runtime.go b/core/vm/sqlvm/runtime/runtime.go
new file mode 100644
index 000000000..ebb4d4579
--- /dev/null
+++ b/core/vm/sqlvm/runtime/runtime.go
@@ -0,0 +1,19 @@
+package runtime
+
+import (
+ "github.com/dexon-foundation/dexon/core/vm"
+ "github.com/dexon-foundation/dexon/core/vm/sqlvm/common"
+)
+
+// Run is runtime entrypoint.
+func Run(stateDB vm.StateDB, ins []Instruction, registers []*Operand) (ret []byte, err error) {
+ for _, in := range ins {
+ opFunc := jumpTable[in.op]
+ err = opFunc(&common.Context{}, in.input, registers, in.output)
+ if err != nil {
+ return nil, err
+ }
+ }
+ // TODO: ret = ABIEncode(ins[len(ins)-1].output)
+ return
+}
--
cgit v1.2.3