## 其他包使用数据库模块
```go
package repository

import (
    "your-project/database"
    "your-project/log"
)

type NodeRepository struct {
    db *database.DB
}

// NewNodeRepository 创建仓库（延迟连接）
func NewNodeRepository() (*NodeRepository, error) {
    db, err := database.GetDB()
    if err != nil {
        return nil, err
    }
    
    return &NodeRepository{db: db}, nil
}

// GetNode 获取节点（自动连接）
func (r *NodeRepository) GetNode(id int) (*Node, error) {
    // 获取数据库引擎（会自动连接）
    engine, err := r.db.GetEngine()
    if err != nil {
        return nil, fmt.Errorf("数据库连接失败: %w", err)
    }
    
    var node Node
    err = engine.QueryRow("SELECT id, name FROM nodes WHERE id = ?", id).
        Scan(&node.ID, &node.Name)
    if err != nil {
        return nil, err
    }
    
    return &node, nil
}

// CreateNode 创建节点
func (r *NodeRepository) CreateNode(name string) error {
    engine, err := r.db.GetEngine()
    if err != nil {
        return err
    }
    
    _, err = engine.Exec("INSERT INTO nodes (name) VALUES (?)", name)
    return err
}
```

## 服务层使用
```go
package service

import (
    "your-project/repository"
    "your-project/log"
)

type NodeService struct {
    repo *repository.NodeRepository
}

func NewNodeService() (*NodeService, error) {
    repo, err := repository.NewNodeRepository()
    if err != nil {
        return nil, err
    }
    
    return &NodeService{repo: repo}, nil
}

func (s *NodeService) ListNode() error {
    // 自动连接数据库
    nodes, err := s.repo.GetAllNodes()
    if err != nil {
        return err
    }
    
    for _, node := range nodes {
        log.Infof("Node: %v", node)
    }
    return nil
}
```
## 命令处理 
```go
package main

import (
    "your-project/cmd"
    "your-project/database"
    "your-project/log"
    "github.com/spf13/cobra"
)

func main() {
    var rootCmd = &cobra.Command{Use: "sunhpc"}
    
    // init database 命令
    var initCmd = &cobra.Command{
        Use:   "init database",
        Short: "初始化数据库",
        Run: func(cmd *cobra.Command, args []string) {
            force, _ := cmd.Flags().GetBool("force")
            
            // 获取DB实例（只加载配置）
            db, err := database.GetDB()
            if err != nil {
                log.Fatal(err)
            }
            
            // 初始化schema（会根据force参数决定行为）
            if err := db.InitSchema(force); err != nil {
                log.Fatal(err)
            }
            
            log.Info("数据库初始化成功")
        },
    }
    initCmd.Flags().BoolP("force", "f", false, "强制重新初始化")
    rootCmd.AddCommand(initCmd)
    
    // node list 命令 - 自动连接已存在的数据库
    var nodeCmd = &cobra.Command{
        Use:   "node list",
        Short: "列出所有节点",
        Run: func(cmd *cobra.Command, args []string) {
            service, err := service.NewNodeService()
            if err != nil {
                log.Fatal(err) // 如果数据库不存在，这里会报错
            }
            
            if err := service.ListNode(); err != nil {
                log.Fatal(err)
            }
        },
    }
    rootCmd.AddCommand(nodeCmd)
    
    rootCmd.Execute()
}
```