Golang DB.Select方法代码示例

func getUsersPost(uid string, allUsers bool, category int64, published string, db *gorm.DB) (posts []models.Post, err error) {
	db = db.Preload("Author").Order("created_at desc")
	if !allUsers {
		db = db.Where("author_id = ?", uid)
	}

	if category != 0 {
		db = db.Joins(
			"join post_categories as pc on posts.id = pc.post_id " +
				"join categories as c on c.id = pc.category_id")

		db = db.Where("c.id = ?", category)
	}

	published = strings.ToLower(published)
	if published != "all" && (published == "true" || published == "false") {
		pub := published == "true"

		db = db.Where("published = ?", pub)
	}

	// the Select call is needed because of a bug.
	// TODO: remove this call when the bug is fixed
	db = db.Select("posts.id, posts.title, posts.content, posts.published, posts.created_at, posts.updated_at, posts.author_id")
	if err = db.Find(&posts).Error; err != nil {
		return nil, err
	}

	return posts, nil
}

func (p *LocaleDao) Get(db *gorm.DB, lang, code string) string {
	l := Locale{}
	db.Select("message").Where("lang = ? AND code = ?", lang, code).First(&l)
	return l.Message
}

func (p *LocaleDao) Set(db *gorm.DB, lang, code, message string) {
	var l Locale
	if db.Select("id").Where("lang = ? AND code = ?", lang, code).First(&l).RecordNotFound() {
		db.Create(&Locale{Lang: lang, Code: code, Message: message})
	} else {
		db.Model(Locale{}).Where("id = ?", l.ID).Updates(Locale{Message: message})
	}
}

func FillSrcInfo(path string, db *gorm.DB) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()
	info, err := srcinfo.ParseSrcInfo(f)
	if err != nil {
		return err
	}
	var oldPkgBase PackageBase
	db.Select("id").First(&oldPkgBase, "pkg_base = ?", info.Global.PkgBase)
	pkgBase := PackageBase{
		ID:          oldPkgBase.ID,
		PkgBase:     info.Global.PkgBase,
		Packages:    []Package{},
		Version:     info.Global.PkgVer,
		Release:     info.Global.PkgRel,
		Depenencies: []Package{},
		Directory:   filepath.Dir(path),
	}
	log.Printf("  {%s}", pkgBase.PkgBase)
	depend := func(dependency string) {
		pkgName := StripDependencyPkgName(dependency)
		log.Printf("    %s => %s", dependency, pkgName)
		var dep Package
		db.FirstOrCreate(&dep, Package{Name: pkgName})
		log.Printf("    %+v", dep)
		pkgBase.Depenencies = append(pkgBase.Depenencies, dep)
	}
	for _, dependency := range info.Global.Depends {
		depend(dependency)
	}
	for _, dependency := range info.Global.MakeDepends {
		depend(dependency)
	}
	for _, pkginfo := range info.Packages {
		for _, dependency := range pkginfo.Depends {
			depend(dependency)
		}
		var pkg Package
		db.FirstOrCreate(&pkg, Package{
			PackageBaseID: pkgBase.ID,
			Name:          pkginfo.PkgName,
		})
		log.Printf("  %s", pkginfo.PkgName)
		pkgBase.Packages = append(pkgBase.Packages, pkg)
	}
	db.Save(&pkgBase)
	return nil
}

func assertExpectedGormTUFMeta(t *testing.T, expected []StoredTUFMeta, gormDB gorm.DB) {
	expectedGorm := make([]TUFFile, len(expected))
	for i, tufObj := range expected {
		expectedGorm[i] = TUFFile{
			Model:   gorm.Model{ID: uint(i + 1)},
			Gun:     tufObj.Gun,
			Role:    tufObj.Role,
			Version: tufObj.Version,
			SHA256:  tufObj.SHA256,
			Data:    tufObj.Data,
		}
	}

	// There should just be one row
	var rows []TUFFile
	query := gormDB.Select("id, gun, role, version, sha256, data").Find(&rows)
	require.NoError(t, query.Error)
	// to avoid issues with nil vs zero len list
	if len(expectedGorm) == 0 {
		require.Len(t, rows, 0)
	} else {
		require.Equal(t, expectedGorm, rows)
	}
}