package main

import (
 "bufio"
 "encoding/json"
 "fmt"
 "log"
 "os/exec"

 "gorm.io/driver/postgres"
 "gorm.io/gorm"
)

type Transaction struct {
 Hash string `gorm:"primaryKey;type:varchar(66)" json:"hash"`
 TransactionIndex int `gorm:"primaryKey" json:"transaction\_index"`
 Nonce int `json:"nonce"`
 BlockTimestamp \*float64 `gorm:"index" json:"block\_timestamp"`
 BlockNumber int `gorm:"index" json:"block\_number"`
 FromAddress string `gorm:"index;type:varchar(42)" json:"from\_address"`
 ToAddress \*string `gorm:"index;type:varchar(42);default:NULL" json:"to\_address"`
 Value float64 `json:"value"`
 Gas float64 `json:"gas"`
 GasPrice float64 `json:"gas\_price"`
 Input string `gorm:"type:text" json:"input"`
 MaxFeePerGas \*float64 `json:"max\_fee\_per\_gas"`
 MaxPriorityFeePerGas \*float64 `json:"max\_priority\_fee\_per\_gas"`
 TransactionType int `json:"transaction\_type"`
}

func main() {
 // Set up the database connection
 dsn := "host=localhost user=postgres password=password dbname=postgres port=5432 sslmode=disable"
 db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
 if err != nil {
 log.Fatalf("Error connecting to the database: %v", err)
 }

 // Migrate the schema
 err = db.AutoMigrate(&Transaction{})
 if err != nil {
 log.Fatalf("Error migrating schema: %v", err)
 }

 cmd := exec.Command("polygonetl", "stream", "--provider-uri", "https://polygon-rpc.com", "-e", "transaction")

 // Create a pipe to the command's standard output stream
 stdoutPipe, err := cmd.StdoutPipe()
 if err != nil {
 log.Fatalf("Error creating stdout pipe: %v", err)
 }

 // Start the command
 err = cmd.Start()
 if err != nil {
 log.Fatalf("Error starting command: %v", err)
 }

 scanner := bufio.NewScanner(stdoutPipe)

 // Batch size for SQL inserts
 const batchSize = 100

 // Continually checks for new scanner output, and processes it
 var txBatch []Transaction
 for scanner.Scan() {
 // Needs to be copied because scanner.Bytes() is reused continuously
 b := make([]byte, len(scanner.Bytes()))
 copy(b, scanner.Bytes())

 var data map[string]interface{}
 err := json.Unmarshal(b, &data)
 if err != nil {
 fmt.Println("Error unmarshalling JSON:", err)
 continue
 }

 entityType, ok := data["type"].(string)
 if !ok {
 log.Fatal("Error: Type not found or not a string")
 continue
 }

 switch entityType {
 case "transaction":
 var tx Transaction
 err := json.Unmarshal(b, &tx)
 if err != nil {
 fmt.Println("Error unmarshalling JSON:", err)
 continue
 }

 // Append to batch slice
 txBatch = append(txBatch, tx)

 // Check if batch size reached
 if len(txBatch) >= batchSize {
 // Insert batch into DB
 result := db.Create(txBatch)
 if result.Error != nil {
 log.Printf("Error inserting transactions: %v", result.Error)
 } else {
 fmt.Printf("%d transactions inserted\n", len(txBatch))
 }

 // Clear batch slice
 txBatch = nil
 }
 }
 }

 // Insert any remaining transactions in batch
 if len(txBatch) > 0 {
 result := db.Create(txBatch)
 if result.Error != nil {
 log.Printf("Error inserting transactions: %v", result.Error)
 } else {
 fmt.Printf("%d transactions inserted\n", len(txBatch))
 }
 }

 // Wait for the command to finish
 err = cmd.Wait()
 if err != nil {
 log.Fatalf("Error waiting for command to finish: %v", err)
 }
}

can you implment gorotuinues to this
패키지 메인

import (
 "bufio"
 "encoding/json"
 "fmt"
 "log"
 "os/exec"

 "gorm.io/driver/postgres"
 "gorm.io/gorm"
)

유형 트랜잭션 구조체 {
 해시 문자열 `gorm:"primaryKey;type:varchar(66)" json:"hash"`
 트랜잭션 인덱스 int `gorm:"primaryKey" json:"transaction\_index"`
 Nonce int `json:"nonce"`
 블록 타임스탬프 \*플로트64 `gorm:"index" json:"block\_timestamp"`
 BlockNumber int `gorm:"index" json:"block\_number"`
 FromAddress 문자열 `gorm:"index;type:varchar(42)" json:"from\_address"`
 ToAddress \*string `gorm:"index;type:varchar(42);default:NULL" json:"to\_address"`
 값 float64 `json:"value"`
 가스 플로트64 `json:"gas"`
 가스 가격 float64 `json:"gas\_price"`
 입력 문자열 `gorm:"type:text" json:"input"`
 MaxFeePerGas \*float64 `json:"max\_fee\_per\_gas"`
 MaxPriorityFeePerGas \*float64 `json:"max\_priority\_fee\_per\_gas"`
 트랜잭션 유형 int `json:"트랜잭션\_type"`
}

func main() {
 // 데이터베이스 연결 설정
 dsn := "호스트=로컬호스트 사용자=포스트그레스 비밀번호=암호 dbname=포스트그레스 포트=5432 ssl모드=비활성화"
 db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
 if err != nil {
 log.Fatalf("데이터베이스에 연결하는 동안 오류가 발생했습니다: %v", err)
 }

 // 스키마 마이그레이션
 err = db.AutoMigrate(&Transaction{})
 if err != nil {
 log.Fatalf("스키마 마이그레이션 중 오류: %v", err)
 }

 cmd := exec.Command("polygonetl", "stream", "--provider-uri", "https://polygon-rpc.com", "-e", "transaction")

 // 명령의 표준 출력 스트림에 대한 파이프를 생성합니다.
 stdoutPipe, err := cmd.StdoutPipe()
 if err != nil {
 log.Fatalf("stdout 파이프 생성 중 오류: %v", err)
 }

 // 명령 시작
 err = cmd.Start()
 if err != nil {
 log.Fatalf("명령 시작 중 오류: %v", err)
 }

 scanner := bufio.NewScanner(stdoutPipe)

 // SQL 삽입을 위한 배치 크기
 const batchSize = 100

 // 새로운 스캐너 출력을 계속 확인하여 처리합니다.
 var txBatch []트랜잭션
 for scanner.Scan() {
 // scanner.Bytes()가 계속 재사용되므로 복사해야 합니다.
 b := make([]byte, len(scanner.Bytes()))
 copy(b, scanner.Bytes())

 var data map[string]interface{}
 err := json.Unmarshal(b, &data)
 if err != nil {
 fmt.Println("JSON을 마샬링 해제하는 동안 오류가 발생했습니다:", err)
 계속
 }

 entityType, ok := data["type"].(문자열)
 if !ok {
 log.Fatal("오류: 유형을 찾을 수 없거나 문자열이 아닙니다.")
 계속
 }

 switch entityType {
 케이스 "트랜잭션":
 var tx 트랜잭션
 err := json.Unmarshal(b, &tx)
 if err != nil {
 fmt.Println("JSON 마샬링 해제 중 오류 발생:", err)
 계속
 }

 // 배치 슬라이스에 추가
 txBatch = append(txBatch, tx)

 // 배치 크기에 도달했는지 확인
 len(txBatch) >= batchSize {
 // DB에 배치 삽입
 result := db.Create(txBatch)
 if result.Error != nil {
 log.Printf("트랜잭션 삽입 중 오류: %v", result.Error)
 } else {
 fmt.Printf("%d 트랜잭션이 삽입되었습니다\n", len(txBatch))
 }

 // 배치 슬라이스 지우기
 txBatch = nil
 }
 }
 }

 // 나머지 트랜잭션을 일괄적으로 삽입합니다.
 len(txBatch) > 0 {
 result := db.Create(txBatch)
 result.Error != nil {
 log.Printf("트랜잭션 삽입 중 오류: %v", result.Error)
 } else {
 fmt.Printf("%d 트랜잭션이 삽입되었습니다\n", len(txBatch))
 }
 }

 // 명령이 완료될 때까지 기다립니다.
 err = cmd.Wait()
 if err != nil {
 log.Fatalf("명령이 완료되기를 기다리는 중 오류 발생: %v", err)
 }
}

고로투를 다음과 같이 임포트할 수 있나요?