crud

package
v0.0.0-...-63185e8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 1, 2023 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source 
const KVTableABI = "" /* 590-byte string literal not displayed */

KVTableABI is the input ABI used to generate the binding from.

View Source 
const TableABI = "" /* 4539-byte string literal not displayed */

TableABI is the input ABI used to generate the binding from.

View Source 
const (
	TableKeyMaxLength int = 255
)
View Source 
const TableManagerABI = "" /* 2024-byte string literal not displayed */

TableManagerABI is the input ABI used to generate the binding from.

Variables

View Source 
var TableManagerAddress = common.HexToAddress("0x1002")

Functions

This section is empty.

Types

type Condition 

type Condition struct {
	Op    uint8
	Field string
	Value string
}

Condition is an auto generated low-level Go binding around an user-defined struct.

type Entry 

type Entry struct {
	Key    string
	Fields []string
}

Entry is an auto generated low-level Go binding around an user-defined struct.

type KVTable 

type KVTable struct {
	KVTableCaller     // Read-only binding to the contract
	KVTableTransactor // Write-only binding to the contract
	KVTableFilterer   // Log filterer for contract events
}

KVTable is an auto generated Go binding around a Solidity contract.

func NewKVTable 

func NewKVTable(address common.Address, backend bind.ContractBackend) (*KVTable, error)

NewKVTable creates a new instance of KVTable, bound to a specific deployed contract.

type KVTableCaller 

type KVTableCaller struct {
	// contains filtered or unexported fields
}

KVTableCaller is an auto generated read-only Go binding around a Solidity contract.

func NewKVTableCaller 

func NewKVTableCaller(address common.Address, caller bind.ContractCaller) (*KVTableCaller, error)

NewKVTableCaller creates a new read-only instance of KVTable, bound to a specific deployed contract.

func (*KVTableCaller) Get 

func (_KVTable *KVTableCaller) Get(opts *bind.CallOpts, key string) (bool, string, error)

Get is a free data retrieval call binding the contract method 0x693ec85e.

Solidity: function get(string key) constant returns(bool, string)

type KVTableCallerRaw 

type KVTableCallerRaw struct {
	Contract *KVTableCaller // Generic read-only contract binding to access the raw methods on
}

KVTableCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*KVTableCallerRaw) Call 

func (_KVTable *KVTableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type KVTableCallerSession 

type KVTableCallerSession struct {
	Contract *KVTableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

KVTableCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*KVTableCallerSession) Get 

func (_KVTable *KVTableCallerSession) Get(key string) (bool, string, error)

Get is a free data retrieval call binding the contract method 0x693ec85e.

Solidity: function get(string key) constant returns(bool, string)

type KVTableFilterer 

type KVTableFilterer struct {
	// contains filtered or unexported fields
}

KVTableFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewKVTableFilterer 

func NewKVTableFilterer(address common.Address, filterer bind.ContractFilterer) (*KVTableFilterer, error)

NewKVTableFilterer creates a new log filterer instance of KVTable, bound to a specific deployed contract.

type KVTableRaw 

type KVTableRaw struct {
	Contract *KVTable // Generic contract binding to access the raw methods on
}

KVTableRaw is an auto generated low-level Go binding around a Solidity contract.

func (*KVTableRaw) Call 

func (_KVTable *KVTableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*KVTableRaw) TransactWithResult 

func (_KVTable *KVTableRaw) TransactWithResult(opts *bind.TransactOpts, result interface{}, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

Transact invokes the (paid) contract method with params as input values.

func (*KVTableRaw) Transfer 

func (_KVTable *KVTableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type KVTableSession 

type KVTableSession struct {
	Contract     *KVTable          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

KVTableSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*KVTableSession) AsyncSet 

func (_KVTable *KVTableSession) AsyncSet(handler func(*types.Receipt, error), key string, value string) (*types.Transaction, error)

func (*KVTableSession) Get 

func (_KVTable *KVTableSession) Get(key string) (bool, string, error)

Get is a free data retrieval call binding the contract method 0x693ec85e.

Solidity: function get(string key) constant returns(bool, string)

func (*KVTableSession) Set 

func (_KVTable *KVTableSession) Set(key string, value string) (int32, *types.Transaction, *types.Receipt, error)

Set is a paid mutator transaction binding the contract method 0xe942b516.

Solidity: function set(string key, string value) returns(int32)

type KVTableTransactor 

type KVTableTransactor struct {
	// contains filtered or unexported fields
}

KVTableTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewKVTableTransactor 

func NewKVTableTransactor(address common.Address, transactor bind.ContractTransactor) (*KVTableTransactor, error)

NewKVTableTransactor creates a new write-only instance of KVTable, bound to a specific deployed contract.

func (*KVTableTransactor) AsyncSet 

func (_KVTable *KVTableTransactor) AsyncSet(handler func(*types.Receipt, error), opts *bind.TransactOpts, key string, value string) (*types.Transaction, error)

func (*KVTableTransactor) Set 

func (_KVTable *KVTableTransactor) Set(opts *bind.TransactOpts, key string, value string) (int32, *types.Transaction, *types.Receipt, error)

Set is a paid mutator transaction binding the contract method 0xe942b516.

Solidity: function set(string key, string value) returns(int32)

type KVTableTransactorRaw 

type KVTableTransactorRaw struct {
	Contract *KVTableTransactor // Generic write-only contract binding to access the raw methods on
}

KVTableTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*KVTableTransactorRaw) TransactWithResult 

func (_KVTable *KVTableTransactorRaw) TransactWithResult(opts *bind.TransactOpts, result interface{}, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

Transact invokes the (paid) contract method with params as input values.

func (*KVTableTransactorRaw) Transfer 

func (_KVTable *KVTableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type KVTableTransactorSession 

type KVTableTransactorSession struct {
	Contract     *KVTableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

KVTableTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*KVTableTransactorSession) AsyncSet 

func (_KVTable *KVTableTransactorSession) AsyncSet(handler func(*types.Receipt, error), key string, value string) (*types.Transaction, error)

func (*KVTableTransactorSession) Set 

func (_KVTable *KVTableTransactorSession) Set(key string, value string) (int32, *types.Transaction, *types.Receipt, error)

Set is a paid mutator transaction binding the contract method 0xe942b516.

Solidity: function set(string key, string value) returns(int32)

type Limit 

type Limit struct {
	Offset uint32
	Count  uint32
}

Limit is an auto generated low-level Go binding around an user-defined struct.

type Service 

type Service struct {
	KVTable *KVTable

	CallOpts *bind.CallOpts
	// contains filtered or unexported fields
}

func NewTableManagerService 

func NewTableManagerService(client *client.Client) (*Service, error)

func (*Service) AppendColumns 

func (service *Service) AppendColumns(path string, newColumns []string) (int64, error)

func (*Service) AsyncAppendColumns 

func (service *Service) AsyncAppendColumns(handler func(*types.Receipt, error), path string, newColumns []string) (*types.Transaction, error)

func (*Service) AsyncCreateKVTable 

func (service *Service) AsyncCreateKVTable(handler func(*types.Receipt, error), tableName string, keyField string, valueField string) (*types.Transaction, error)

func (*Service) AsyncCreateTable 

func (service *Service) AsyncCreateTable(handler func(*types.Receipt, error), tableName string, key string, valueFields []string) (*types.Transaction, error)

func (*Service) AsyncInsert 

func (service *Service) AsyncInsert(handler func(*types.Receipt, error), tableName string, entry Entry) (*types.Transaction, error)

func (*Service) AsyncRemove 

func (service *Service) AsyncRemove(handler func(*types.Receipt, error), tableName string, key string) (*types.Transaction, error)

func (*Service) AsyncRemove0 

func (service *Service) AsyncRemove0(handler func(*types.Receipt, error), tableName string, conditions []Condition, limit Limit) (*types.Transaction, error)

func (*Service) AsyncUpdate 

func (service *Service) AsyncUpdate(handler func(*types.Receipt, error), tableName string, key string, updateFields []UpdateField) (*types.Transaction, error)

func (*Service) AsyncUpdate0 

func (service *Service) AsyncUpdate0(handler func(*types.Receipt, error), tableName string, conditions []Condition, limit Limit, updateFields []UpdateField) (*types.Transaction, error)

func (*Service) CreateKVTable 

func (service *Service) CreateKVTable(tableName string, keyField string, valueField string) (int64, error)

func (*Service) CreateTable 

func (service *Service) CreateTable(tableName string, key string, valueFields []string) (int64, error)

*

  • **************************************************************************************************************
  • TableManager
  • **************************************************************************************************************

*

func (*Service) DescWithKeyOrder 

func (service *Service) DescWithKeyOrder(tableName string) (TableInfo, error)

func (*Service) Get 

func (service *Service) Get(tableName string, key string) (bool, string, error)

func (*Service) Insert 

func (service *Service) Insert(tableName string, entry Entry) (int64, error)

*

  • **************************************************************************************************************
  • Table
  • **************************************************************************************************************

*

func (*Service) OpenKVTable 

func (service *Service) OpenKVTable(tableName string) (int64, error)

func (*Service) OpenTable 

func (service *Service) OpenTable(tableName string) (int64, error)

func (*Service) Remove 

func (service *Service) Remove(tableName string, key string) (int64, error)

func (*Service) Remove0 

func (service *Service) Remove0(tableName string, conditions []Condition, limit Limit) (int64, error)

func (*Service) Select 

func (service *Service) Select(tableName string, conditions []Condition, limit Limit) ([]Entry, error)

func (*Service) Select0 

func (service *Service) Select0(tableName string, key string) (Entry, error)

func (*Service) Set 

func (service *Service) Set(tableName string, key string, value string) (int64, error)

*

  • **************************************************************************************************************
  • KVTable
  • **************************************************************************************************************

*

func (*Service) Update 

func (service *Service) Update(tableName string, key string, updateFields []UpdateField) (int64, error)

func (*Service) Update0 

func (service *Service) Update0(tableName string, conditions []Condition, limit Limit, updateFields []UpdateField) (int64, error)

type Table 

type Table struct {
	TableCaller     // Read-only binding to the contract
	TableTransactor // Write-only binding to the contract
	TableFilterer   // Log filterer for contract events
}

Table is an auto generated Go binding around a Solidity contract.

func NewTable 

func NewTable(address common.Address, backend bind.ContractBackend) (*Table, error)

NewTable creates a new instance of Table, bound to a specific deployed contract.

type TableCaller 

type TableCaller struct {
	// contains filtered or unexported fields
}

TableCaller is an auto generated read-only Go binding around a Solidity contract.

func NewTableCaller 

func NewTableCaller(address common.Address, caller bind.ContractCaller) (*TableCaller, error)

NewTableCaller creates a new read-only instance of Table, bound to a specific deployed contract.

func (*TableCaller) Count 

func (_Table *TableCaller) Count(opts *bind.CallOpts, conditions []Condition) (uint32, error)

Count is a free data retrieval call binding the contract method 0xda46335f.

Solidity: function count([]Condition conditions) constant returns(uint32)

func (*TableCaller) Select 

func (_Table *TableCaller) Select(opts *bind.CallOpts, conditions []Condition, limit Limit) ([]Entry, error)

Select is a free data retrieval call binding the contract method 0x2a922441.

Solidity: function select([]Condition conditions, Limit limit) constant returns([]Entry)

func (*TableCaller) Select0 

func (_Table *TableCaller) Select0(opts *bind.CallOpts, key string) (Entry, error)

Select0 is a free data retrieval call binding the contract method 0xfcd7e3c1.

Solidity: function select(string key) constant returns(Entry)

type TableCallerRaw 

type TableCallerRaw struct {
	Contract *TableCaller // Generic read-only contract binding to access the raw methods on
}

TableCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*TableCallerRaw) Call 

func (_Table *TableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type TableCallerSession 

type TableCallerSession struct {
	Contract *TableCaller  // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

TableCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*TableCallerSession) Count 

func (_Table *TableCallerSession) Count(conditions []Condition) (uint32, error)

Count is a free data retrieval call binding the contract method 0xda46335f.

Solidity: function count([]Condition conditions) constant returns(uint32)

func (*TableCallerSession) Select 

func (_Table *TableCallerSession) Select(conditions []Condition, limit Limit) ([]Entry, error)

Select is a free data retrieval call binding the contract method 0x2a922441.

Solidity: function select([]Condition conditions, Limit limit) constant returns([]Entry)

func (*TableCallerSession) Select0 

func (_Table *TableCallerSession) Select0(key string) (Entry, error)

Select0 is a free data retrieval call binding the contract method 0xfcd7e3c1.

Solidity: function select(string key) constant returns(Entry)

type TableFilterer 

type TableFilterer struct {
	// contains filtered or unexported fields
}

TableFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewTableFilterer 

func NewTableFilterer(address common.Address, filterer bind.ContractFilterer) (*TableFilterer, error)

NewTableFilterer creates a new log filterer instance of Table, bound to a specific deployed contract.

type TableInfo 

type TableInfo struct {
	KeyOrder     uint8
	KeyColumn    string
	ValueColumns []string
}

TableInfo is an auto generated low-level Go binding around an user-defined struct.

type TableManager 

type TableManager struct {
	TableManagerCaller     // Read-only binding to the contract
	TableManagerTransactor // Write-only binding to the contract
	TableManagerFilterer   // Log filterer for contract events
}

TableManager is an auto generated Go binding around a Solidity contract.

func NewTableManager 

func NewTableManager(address common.Address, backend bind.ContractBackend) (*TableManager, error)

NewTableManager creates a new instance of TableManager, bound to a specific deployed contract.

type TableManagerCaller 

type TableManagerCaller struct {
	// contains filtered or unexported fields
}

TableManagerCaller is an auto generated read-only Go binding around a Solidity contract.

func NewTableManagerCaller 

func NewTableManagerCaller(address common.Address, caller bind.ContractCaller) (*TableManagerCaller, error)

NewTableManagerCaller creates a new read-only instance of TableManager, bound to a specific deployed contract.

func (*TableManagerCaller) DescWithKeyOrder 

func (_TableManager *TableManagerCaller) DescWithKeyOrder(opts *bind.CallOpts, tableName string) (TableInfo, error)

DescWithKeyOrder is a free data retrieval call binding the contract method 0xb8764d3f.

Solidity: function descWithKeyOrder(string tableName) constant returns(TableInfo)

func (*TableManagerCaller) OpenTable 

func (_TableManager *TableManagerCaller) OpenTable(opts *bind.CallOpts, path string) (common.Address, error)

OpenTable is a free data retrieval call binding the contract method 0xf23f63c9.

Solidity: function openTable(string path) constant returns(address)

type TableManagerCallerRaw 

type TableManagerCallerRaw struct {
	Contract *TableManagerCaller // Generic read-only contract binding to access the raw methods on
}

TableManagerCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*TableManagerCallerRaw) Call 

func (_TableManager *TableManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type TableManagerCallerSession 

type TableManagerCallerSession struct {
	Contract *TableManagerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts       // Call options to use throughout this session
}

TableManagerCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*TableManagerCallerSession) DescWithKeyOrder 

func (_TableManager *TableManagerCallerSession) DescWithKeyOrder(tableName string) (TableInfo, error)

DescWithKeyOrder is a free data retrieval call binding the contract method 0xb8764d3f.

Solidity: function descWithKeyOrder(string tableName) constant returns(TableInfo)

func (*TableManagerCallerSession) OpenTable 

func (_TableManager *TableManagerCallerSession) OpenTable(path string) (common.Address, error)

OpenTable is a free data retrieval call binding the contract method 0xf23f63c9.

Solidity: function openTable(string path) constant returns(address)

type TableManagerFilterer 

type TableManagerFilterer struct {
	// contains filtered or unexported fields
}

TableManagerFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewTableManagerFilterer 

func NewTableManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*TableManagerFilterer, error)

NewTableManagerFilterer creates a new log filterer instance of TableManager, bound to a specific deployed contract.

type TableManagerRaw 

type TableManagerRaw struct {
	Contract *TableManager // Generic contract binding to access the raw methods on
}

TableManagerRaw is an auto generated low-level Go binding around a Solidity contract.

func (*TableManagerRaw) Call 

func (_TableManager *TableManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*TableManagerRaw) TransactWithResult 

func (_TableManager *TableManagerRaw) TransactWithResult(opts *bind.TransactOpts, result interface{}, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

Transact invokes the (paid) contract method with params as input values.

func (*TableManagerRaw) Transfer 

func (_TableManager *TableManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TableManagerSession 

type TableManagerSession struct {
	Contract     *TableManager     // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

TableManagerSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*TableManagerSession) AppendColumns 

func (_TableManager *TableManagerSession) AppendColumns(path string, newColumns []string) (int32, *types.Transaction, *types.Receipt, error)

AppendColumns is a paid mutator transaction binding the contract method 0x302baee0.

Solidity: function appendColumns(string path, string[] newColumns) returns(int32)

func (*TableManagerSession) AsyncAppendColumns 

func (_TableManager *TableManagerSession) AsyncAppendColumns(handler func(*types.Receipt, error), path string, newColumns []string) (*types.Transaction, error)

func (*TableManagerSession) AsyncCreateKVTable 

func (_TableManager *TableManagerSession) AsyncCreateKVTable(handler func(*types.Receipt, error), tableName string, keyField string, valueField string) (*types.Transaction, error)

func (*TableManagerSession) AsyncCreateTable 

func (_TableManager *TableManagerSession) AsyncCreateTable(handler func(*types.Receipt, error), path string, tableInfo TableInfo) (*types.Transaction, error)

func (*TableManagerSession) CreateKVTable 

func (_TableManager *TableManagerSession) CreateKVTable(tableName string, keyField string, valueField string) (int32, *types.Transaction, *types.Receipt, error)

CreateKVTable is a paid mutator transaction binding the contract method 0xb0e89adb.

Solidity: function createKVTable(string tableName, string keyField, string valueField) returns(int32)

func (*TableManagerSession) CreateTable 

func (_TableManager *TableManagerSession) CreateTable(path string, tableInfo TableInfo) (int32, *types.Transaction, *types.Receipt, error)

CreateTable is a paid mutator transaction binding the contract method 0x75b14eea.

Solidity: function createTable(string path, TableInfo tableInfo) returns(int32)

func (*TableManagerSession) DescWithKeyOrder 

func (_TableManager *TableManagerSession) DescWithKeyOrder(tableName string) (TableInfo, error)

DescWithKeyOrder is a free data retrieval call binding the contract method 0xb8764d3f.

Solidity: function descWithKeyOrder(string tableName) constant returns(TableInfo)

func (*TableManagerSession) OpenTable 

func (_TableManager *TableManagerSession) OpenTable(path string) (common.Address, error)

OpenTable is a free data retrieval call binding the contract method 0xf23f63c9.

Solidity: function openTable(string path) constant returns(address)

type TableManagerTransactor 

type TableManagerTransactor struct {
	// contains filtered or unexported fields
}

TableManagerTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewTableManagerTransactor 

func NewTableManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*TableManagerTransactor, error)

NewTableManagerTransactor creates a new write-only instance of TableManager, bound to a specific deployed contract.

func (*TableManagerTransactor) AppendColumns 

func (_TableManager *TableManagerTransactor) AppendColumns(opts *bind.TransactOpts, path string, newColumns []string) (int32, *types.Transaction, *types.Receipt, error)

AppendColumns is a paid mutator transaction binding the contract method 0x302baee0.

Solidity: function appendColumns(string path, string[] newColumns) returns(int32)

func (*TableManagerTransactor) AsyncAppendColumns 

func (_TableManager *TableManagerTransactor) AsyncAppendColumns(handler func(*types.Receipt, error), opts *bind.TransactOpts, path string, newColumns []string) (*types.Transaction, error)

func (*TableManagerTransactor) AsyncCreateKVTable 

func (_TableManager *TableManagerTransactor) AsyncCreateKVTable(handler func(*types.Receipt, error), opts *bind.TransactOpts, tableName string, keyField string, valueField string) (*types.Transaction, error)

func (*TableManagerTransactor) AsyncCreateTable 

func (_TableManager *TableManagerTransactor) AsyncCreateTable(handler func(*types.Receipt, error), opts *bind.TransactOpts, path string, tableInfo TableInfo) (*types.Transaction, error)

func (*TableManagerTransactor) CreateKVTable 

func (_TableManager *TableManagerTransactor) CreateKVTable(opts *bind.TransactOpts, tableName string, keyField string, valueField string) (int32, *types.Transaction, *types.Receipt, error)

CreateKVTable is a paid mutator transaction binding the contract method 0xb0e89adb.

Solidity: function createKVTable(string tableName, string keyField, string valueField) returns(int32)

func (*TableManagerTransactor) CreateTable 

func (_TableManager *TableManagerTransactor) CreateTable(opts *bind.TransactOpts, path string, tableInfo TableInfo) (int32, *types.Transaction, *types.Receipt, error)

CreateTable is a paid mutator transaction binding the contract method 0x75b14eea.

Solidity: function createTable(string path, TableInfo tableInfo) returns(int32)

type TableManagerTransactorRaw 

type TableManagerTransactorRaw struct {
	Contract *TableManagerTransactor // Generic write-only contract binding to access the raw methods on
}

TableManagerTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*TableManagerTransactorRaw) TransactWithResult 

func (_TableManager *TableManagerTransactorRaw) TransactWithResult(opts *bind.TransactOpts, result interface{}, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

Transact invokes the (paid) contract method with params as input values.

func (*TableManagerTransactorRaw) Transfer 

func (_TableManager *TableManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TableManagerTransactorSession 

type TableManagerTransactorSession struct {
	Contract     *TableManagerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

TableManagerTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*TableManagerTransactorSession) AppendColumns 

func (_TableManager *TableManagerTransactorSession) AppendColumns(path string, newColumns []string) (int32, *types.Transaction, *types.Receipt, error)

AppendColumns is a paid mutator transaction binding the contract method 0x302baee0.

Solidity: function appendColumns(string path, string[] newColumns) returns(int32)

func (*TableManagerTransactorSession) AsyncAppendColumns 

func (_TableManager *TableManagerTransactorSession) AsyncAppendColumns(handler func(*types.Receipt, error), path string, newColumns []string) (*types.Transaction, error)

func (*TableManagerTransactorSession) AsyncCreateKVTable 

func (_TableManager *TableManagerTransactorSession) AsyncCreateKVTable(handler func(*types.Receipt, error), tableName string, keyField string, valueField string) (*types.Transaction, error)

func (*TableManagerTransactorSession) AsyncCreateTable 

func (_TableManager *TableManagerTransactorSession) AsyncCreateTable(handler func(*types.Receipt, error), path string, tableInfo TableInfo) (*types.Transaction, error)

func (*TableManagerTransactorSession) CreateKVTable 

func (_TableManager *TableManagerTransactorSession) CreateKVTable(tableName string, keyField string, valueField string) (int32, *types.Transaction, *types.Receipt, error)

CreateKVTable is a paid mutator transaction binding the contract method 0xb0e89adb.

Solidity: function createKVTable(string tableName, string keyField, string valueField) returns(int32)

func (*TableManagerTransactorSession) CreateTable 

func (_TableManager *TableManagerTransactorSession) CreateTable(path string, tableInfo TableInfo) (int32, *types.Transaction, *types.Receipt, error)

CreateTable is a paid mutator transaction binding the contract method 0x75b14eea.

Solidity: function createTable(string path, TableInfo tableInfo) returns(int32)

type TableRaw 

type TableRaw struct {
	Contract *Table // Generic contract binding to access the raw methods on
}

TableRaw is an auto generated low-level Go binding around a Solidity contract.

func (*TableRaw) Call 

func (_Table *TableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*TableRaw) TransactWithResult 

func (_Table *TableRaw) TransactWithResult(opts *bind.TransactOpts, result interface{}, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

Transact invokes the (paid) contract method with params as input values.

func (*TableRaw) Transfer 

func (_Table *TableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TableSession 

type TableSession struct {
	Contract     *Table            // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

TableSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*TableSession) AsyncInsert 

func (_Table *TableSession) AsyncInsert(handler func(*types.Receipt, error), entry Entry) (*types.Transaction, error)

func (*TableSession) AsyncRemove 

func (_Table *TableSession) AsyncRemove(handler func(*types.Receipt, error), key string) (*types.Transaction, error)

func (*TableSession) AsyncRemove0 

func (_Table *TableSession) AsyncRemove0(handler func(*types.Receipt, error), conditions []Condition, limit Limit) (*types.Transaction, error)

func (*TableSession) AsyncUpdate 

func (_Table *TableSession) AsyncUpdate(handler func(*types.Receipt, error), key string, updateFields []UpdateField) (*types.Transaction, error)

func (*TableSession) AsyncUpdate0 

func (_Table *TableSession) AsyncUpdate0(handler func(*types.Receipt, error), conditions []Condition, limit Limit, updateFields []UpdateField) (*types.Transaction, error)

func (*TableSession) Count 

func (_Table *TableSession) Count(conditions []Condition) (uint32, error)

Count is a free data retrieval call binding the contract method 0xda46335f.

Solidity: function count([]Condition conditions) constant returns(uint32)

func (*TableSession) Insert 

func (_Table *TableSession) Insert(entry Entry) (int32, *types.Transaction, *types.Receipt, error)

Insert is a paid mutator transaction binding the contract method 0x5c6e105f.

Solidity: function insert(Entry entry) returns(int32)

func (*TableSession) Remove 

func (_Table *TableSession) Remove(key string) (int32, *types.Transaction, *types.Receipt, error)

Remove is a paid mutator transaction binding the contract method 0x80599e4b.

Solidity: function remove(string key) returns(int32)

func (*TableSession) Remove0 

func (_Table *TableSession) Remove0(conditions []Condition, limit Limit) (int32, *types.Transaction, *types.Receipt, error)

Remove0 is a paid mutator transaction binding the contract method 0xa7260717.

Solidity: function remove([]Condition conditions, Limit limit) returns(int32)

func (*TableSession) Select 

func (_Table *TableSession) Select(conditions []Condition, limit Limit) ([]Entry, error)

Select is a free data retrieval call binding the contract method 0x2a922441.

Solidity: function select([]Condition conditions, Limit limit) constant returns([]Entry)

func (*TableSession) Select0 

func (_Table *TableSession) Select0(key string) (Entry, error)

Select0 is a free data retrieval call binding the contract method 0xfcd7e3c1.

Solidity: function select(string key) constant returns(Entry)

func (*TableSession) Update 

func (_Table *TableSession) Update(key string, updateFields []UpdateField) (int32, *types.Transaction, *types.Receipt, error)

Update is a paid mutator transaction binding the contract method 0x41ffd75f.

Solidity: function update(string key, []UpdateField updateFields) returns(int32)

func (*TableSession) Update0 

func (_Table *TableSession) Update0(conditions []Condition, limit Limit, updateFields []UpdateField) (int32, *types.Transaction, *types.Receipt, error)

Update0 is a paid mutator transaction binding the contract method 0x9924c17e.

Solidity: function update([]Condition conditions, Limit limit, []UpdateField updateFields) returns(int32)

type TableTransactor 

type TableTransactor struct {
	// contains filtered or unexported fields
}

TableTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewTableTransactor 

func NewTableTransactor(address common.Address, transactor bind.ContractTransactor) (*TableTransactor, error)

NewTableTransactor creates a new write-only instance of Table, bound to a specific deployed contract.

func (*TableTransactor) AsyncInsert 

func (_Table *TableTransactor) AsyncInsert(handler func(*types.Receipt, error), opts *bind.TransactOpts, entry Entry) (*types.Transaction, error)

func (*TableTransactor) AsyncRemove 

func (_Table *TableTransactor) AsyncRemove(handler func(*types.Receipt, error), opts *bind.TransactOpts, key string) (*types.Transaction, error)

func (*TableTransactor) AsyncRemove0 

func (_Table *TableTransactor) AsyncRemove0(handler func(*types.Receipt, error), opts *bind.TransactOpts, conditions []Condition, limit Limit) (*types.Transaction, error)

func (*TableTransactor) AsyncUpdate 

func (_Table *TableTransactor) AsyncUpdate(handler func(*types.Receipt, error), opts *bind.TransactOpts, key string, updateFields []UpdateField) (*types.Transaction, error)

func (*TableTransactor) AsyncUpdate0 

func (_Table *TableTransactor) AsyncUpdate0(handler func(*types.Receipt, error), opts *bind.TransactOpts, conditions []Condition, limit Limit, updateFields []UpdateField) (*types.Transaction, error)

func (*TableTransactor) Insert 

func (_Table *TableTransactor) Insert(opts *bind.TransactOpts, entry Entry) (int32, *types.Transaction, *types.Receipt, error)

Insert is a paid mutator transaction binding the contract method 0x5c6e105f.

Solidity: function insert(Entry entry) returns(int32)

func (*TableTransactor) Remove 

func (_Table *TableTransactor) Remove(opts *bind.TransactOpts, key string) (int32, *types.Transaction, *types.Receipt, error)

Remove is a paid mutator transaction binding the contract method 0x80599e4b.

Solidity: function remove(string key) returns(int32)

func (*TableTransactor) Remove0 

func (_Table *TableTransactor) Remove0(opts *bind.TransactOpts, conditions []Condition, limit Limit) (int32, *types.Transaction, *types.Receipt, error)

Remove0 is a paid mutator transaction binding the contract method 0xa7260717.

Solidity: function remove([]Condition conditions, Limit limit) returns(int32)

func (*TableTransactor) Update 

func (_Table *TableTransactor) Update(opts *bind.TransactOpts, key string, updateFields []UpdateField) (int32, *types.Transaction, *types.Receipt, error)

Update is a paid mutator transaction binding the contract method 0x41ffd75f.

Solidity: function update(string key, []UpdateField updateFields) returns(int32)

func (*TableTransactor) Update0 

func (_Table *TableTransactor) Update0(opts *bind.TransactOpts, conditions []Condition, limit Limit, updateFields []UpdateField) (int32, *types.Transaction, *types.Receipt, error)

Update0 is a paid mutator transaction binding the contract method 0x9924c17e.

Solidity: function update([]Condition conditions, Limit limit, []UpdateField updateFields) returns(int32)

type TableTransactorRaw 

type TableTransactorRaw struct {
	Contract *TableTransactor // Generic write-only contract binding to access the raw methods on
}

TableTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*TableTransactorRaw) TransactWithResult 

func (_Table *TableTransactorRaw) TransactWithResult(opts *bind.TransactOpts, result interface{}, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

Transact invokes the (paid) contract method with params as input values.

func (*TableTransactorRaw) Transfer 

func (_Table *TableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TableTransactorSession 

type TableTransactorSession struct {
	Contract     *TableTransactor  // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

TableTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*TableTransactorSession) AsyncInsert 

func (_Table *TableTransactorSession) AsyncInsert(handler func(*types.Receipt, error), entry Entry) (*types.Transaction, error)

func (*TableTransactorSession) AsyncRemove 

func (_Table *TableTransactorSession) AsyncRemove(handler func(*types.Receipt, error), key string) (*types.Transaction, error)

func (*TableTransactorSession) AsyncRemove0 

func (_Table *TableTransactorSession) AsyncRemove0(handler func(*types.Receipt, error), conditions []Condition, limit Limit) (*types.Transaction, error)

func (*TableTransactorSession) AsyncUpdate 

func (_Table *TableTransactorSession) AsyncUpdate(handler func(*types.Receipt, error), key string, updateFields []UpdateField) (*types.Transaction, error)

func (*TableTransactorSession) AsyncUpdate0 

func (_Table *TableTransactorSession) AsyncUpdate0(handler func(*types.Receipt, error), conditions []Condition, limit Limit, updateFields []UpdateField) (*types.Transaction, error)

func (*TableTransactorSession) Insert 

func (_Table *TableTransactorSession) Insert(entry Entry) (int32, *types.Transaction, *types.Receipt, error)

Insert is a paid mutator transaction binding the contract method 0x5c6e105f.

Solidity: function insert(Entry entry) returns(int32)

func (*TableTransactorSession) Remove 

func (_Table *TableTransactorSession) Remove(key string) (int32, *types.Transaction, *types.Receipt, error)

Remove is a paid mutator transaction binding the contract method 0x80599e4b.

Solidity: function remove(string key) returns(int32)

func (*TableTransactorSession) Remove0 

func (_Table *TableTransactorSession) Remove0(conditions []Condition, limit Limit) (int32, *types.Transaction, *types.Receipt, error)

Remove0 is a paid mutator transaction binding the contract method 0xa7260717.

Solidity: function remove([]Condition conditions, Limit limit) returns(int32)

func (*TableTransactorSession) Update 

func (_Table *TableTransactorSession) Update(key string, updateFields []UpdateField) (int32, *types.Transaction, *types.Receipt, error)

Update is a paid mutator transaction binding the contract method 0x41ffd75f.

Solidity: function update(string key, []UpdateField updateFields) returns(int32)

func (*TableTransactorSession) Update0 

func (_Table *TableTransactorSession) Update0(conditions []Condition, limit Limit, updateFields []UpdateField) (int32, *types.Transaction, *types.Receipt, error)

Update0 is a paid mutator transaction binding the contract method 0x9924c17e.

Solidity: function update([]Condition conditions, Limit limit, []UpdateField updateFields) returns(int32)

type UpdateField 

type UpdateField struct {
	ColumnName string
	Value      string
}

UpdateField is an auto generated low-level Go binding around an user-defined struct.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.