github.com/matrixorigin/matrixone@v0.7.0/pkg/txn/storage/memorystorage/write.go (about)

     1  // Copyright 2022 Matrix Origin
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package memorystorage
    16  
    17  import (
    18  	"bytes"
    19  	"context"
    20  	"encoding/gob"
    21  
    22  	"github.com/matrixorigin/matrixone/pkg/pb/txn"
    23  	"github.com/matrixorigin/matrixone/pkg/vm/engine/memoryengine"
    24  )
    25  
    26  func (s *Storage) Write(ctx context.Context, txnMeta txn.TxnMeta, op uint32, payload []byte) (result []byte, err error) {
    27  
    28  	switch op {
    29  
    30  	case memoryengine.OpCreateDatabase:
    31  		return handleWrite(
    32  			ctx, txnMeta, payload,
    33  			s.handler.HandleCreateDatabase,
    34  		)
    35  
    36  	case memoryengine.OpDeleteDatabase:
    37  		return handleWrite(
    38  			ctx, txnMeta, payload,
    39  			s.handler.HandleDeleteDatabase,
    40  		)
    41  
    42  	case memoryengine.OpCreateRelation:
    43  		return handleWrite(
    44  			ctx, txnMeta, payload,
    45  			s.handler.HandleCreateRelation,
    46  		)
    47  
    48  	case memoryengine.OpDeleteRelation:
    49  		return handleWrite(
    50  			ctx, txnMeta, payload,
    51  			s.handler.HandleDeleteRelation,
    52  		)
    53  
    54  	case memoryengine.OpTruncateRelation:
    55  		return handleWrite(
    56  			ctx, txnMeta, payload,
    57  			s.handler.HandleTruncateRelation,
    58  		)
    59  
    60  	case memoryengine.OpAddTableDef:
    61  		return handleWrite(
    62  			ctx, txnMeta, payload,
    63  			s.handler.HandleAddTableDef,
    64  		)
    65  
    66  	case memoryengine.OpDelTableDef:
    67  		return handleWrite(
    68  			ctx, txnMeta, payload,
    69  			s.handler.HandleDelTableDef,
    70  		)
    71  
    72  	case memoryengine.OpDelete:
    73  		return handleWrite(
    74  			ctx, txnMeta, payload,
    75  			s.handler.HandleDelete,
    76  		)
    77  
    78  	//case memoryengine.OpTruncate:
    79  	//	return handleWrite(
    80  	//		ctx, txnMeta, payload,
    81  	//		s.handler.HandleTruncate,
    82  	//	)
    83  
    84  	case memoryengine.OpUpdate:
    85  		return handleWrite(
    86  			ctx, txnMeta, payload,
    87  			s.handler.HandleUpdate,
    88  		)
    89  
    90  	case memoryengine.OpWrite:
    91  		return handleWrite(
    92  			ctx, txnMeta, payload,
    93  			s.handler.HandleWrite,
    94  		)
    95  
    96  	}
    97  
    98  	return
    99  }
   100  
   101  func handleWrite[
   102  	Req any,
   103  	Resp any,
   104  ](
   105  	ctx context.Context,
   106  	meta txn.TxnMeta,
   107  	payload []byte,
   108  	fn func(
   109  		ctx context.Context,
   110  		meta txn.TxnMeta,
   111  		req Req,
   112  		resp *Resp,
   113  	) (
   114  		err error,
   115  	),
   116  ) (
   117  	res []byte,
   118  	err error,
   119  ) {
   120  
   121  	var req Req
   122  	if err := gob.NewDecoder(bytes.NewReader(payload)).Decode(&req); err != nil {
   123  		return nil, err
   124  	}
   125  
   126  	var resp Resp
   127  	defer logReq("write", req, meta, &resp, &err)()
   128  
   129  	err = fn(ctx, meta, req, &resp)
   130  	if err != nil {
   131  		return nil, err
   132  	}
   133  
   134  	buf := new(bytes.Buffer)
   135  	if err := gob.NewEncoder(buf).Encode(resp); err != nil {
   136  		return nil, err
   137  	}
   138  	res = buf.Bytes()
   139  
   140  	return
   141  }