Mercurial > hg > uwbuild / file revision

package main

import (
	"database/sql"
	"log"
	"path"

	_ "modernc.org/sqlite"
)

func db_init() *sql.DB {
	db, err := sql.Open("sqlite", "uwbuild.db")
	if err != nil {
		log.Fatal(err)
	}

	err = db_prepare(db)
	if err != nil {
		log.Fatal(err)
	}

	return db
}

func db_prepare(db *sql.DB) error {
	_, err := db.Exec("select id from Repository")
	if err == nil {
		return nil
	}

	_, err = db.Exec(`
	create table Repository (
		id integer primary key autoincrement,
		path text not null unique,
		name text not null
	);
	create table CommitInfo (
	    id integer primary key autoincrement,
	    repository_id integer not null references Repository(id),
	    node text,
	    node_short text,
	    author text,
	    description text,
	    date text
	);
	create table BuildEnv (
	    id integer primary key autoincrement,
	    name text not null unique,
	    host text,
	    os text
	);
	create table BuildEnvResult (
	    id integer primary key autoincrement,
	    buildenv_id integer not null references BuildEnv(id),
	    commit_id integer not null references CommitInfo(id)
	);
	create table BuildResult (
	    id integer primary key autoincrement,
	    buildenvresult_id integer not null references BuildEnvResult(id),
	    name text,
	    isplatform text,
	    notplatform text,
	    config text,
	    configure_cmd text,
	    compile_cmd text,
	    check_cmd text,
	    configure_result integer,
	    compile_result integer,
	    check_result integer
	);

	`)
	return err
}

func db_load_config(db *sql.DB, config *Config) {
	for _, repo := range config.Repository {
		_, err := db.Exec(`
			insert into Repository(path, name)
			values (?, ?)
			on conflict(path) do nothing`, repo.Path, path.Base(repo.Path))
		if err != nil {
			log.Fatal(err)
		}
	}

	for _, buildenv := range config.BuildEnv {
		_, err := db.Exec(`
			insert into BuildEnv(name, host, os)
			values (?, ?, ?)
			on conflict(name) do update set
			host = ?2, os = ?3;`, buildenv.Name, buildenv.Host, buildenv.OS)
		if err != nil {
			log.Fatal(err)
		}
	}
}

func db_store_results(db *sql.DB, repo *Repository, commit *Commit, result []BuildEnvResult) error {
	r, err := db.Exec(`
		insert into CommitInfo(repository_id, node, node_short, author, description, date)
		values ((select id from repository where path = ?), ?, ?, ?, ?, ?)
	`, repo.Path, commit.Node, commit.NodeShort, commit.Author, commit.Desc, commit.Date)
	if err != nil {
		log.Fatal(err)
	}
	repo_id, err := r.LastInsertId()
	if err != nil {
		log.Fatal(err)
	}

	for _, res := range result {
		r, err := db.Exec(`
			insert into BuildEnvResult(buildenv_id, commit_id) 
			values ((select id from BuildEnv where name = ?), ?)
		`, res.Env.Name, repo_id)
		if err != nil {
			return err
		}
		buildenvresult_id, err := r.LastInsertId()

		for _, build := range res.Results {
			_, err = db.Exec(`
				insert into BuildResult(buildenvresult_id, name, isplatform, notplatform, config,
										configure_cmd, compile_cmd, check_cmd, configure_result, compile_result, check_result)
				values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
			`, buildenvresult_id, build.Build.Name, build.Build.IsPlatform, build.Build.NotPlatform, "",
				build.Build.Configure, build.Build.Compile, build.Build.Check,
				build.Configure, build.Compile, build.Check)
		}

	}

	return nil
}