// DecompressAndLoad will load or fetch a graph from the given path, decompress
// it, and then call the given load function to process the decompressed graph.
// If no loadFn is provided, db.Load is called.
func DecompressAndLoad(qw graph.QuadWriter, cfg *config.Config, path, typ string, loadFn func(graph.QuadWriter, *config.Config, quad.Reader) error) error {
var r io.Reader
if path == "" {
path = cfg.DatabasePath
}
if path == "" {
return nil
}
u, err := url.Parse(path)
if err != nil || u.Scheme == "file" || u.Scheme == "" {
// Don't alter relative URL path or non-URL path parameter.
if u.Scheme != "" && err == nil {
// Recovery heuristic for mistyping "file://path/to/file".
path = filepath.Join(u.Host, u.Path)
}
f, err := os.Open(path)
if err != nil {
return fmt.Errorf("could not open file %q: %v", path, err)
}
defer f.Close()
r = f
} else {
res, err := client.Get(path)
if err != nil {
return fmt.Errorf("could not get resource <%s>: %v", u, err)
}
defer res.Body.Close()
r = res.Body
}
r, err = Decompressor(r)
if err != nil {
if err == io.EOF {
return nil
}
return err
}
var dec quad.ReadCloser
switch typ {
case "cquad", "cquads":
dec = cquads.NewDecoder(r)
case "nquad", "nquads":
dec = nquads.NewDecoder(r)
default:
format := quad.FormatByName(typ)
if format == nil || format.Reader == nil {
return fmt.Errorf("unknown quad format %q", typ)
}
dec = format.Reader(r)
}
defer dec.Close()
if loadFn != nil {
return loadFn(qw, cfg, dec)
}
return db.Load(qw, cfg, dec)
}
// Dump the content of the database into a file based
// on a few different formats
func Dump(qs graph.QuadStore, outFile, typ string) error {
var f *os.File
if outFile == "-" {
f = os.Stdout
} else {
var err error
f, err = os.Create(outFile)
if err != nil {
return fmt.Errorf("could not open file %q: %v", outFile, err)
}
defer f.Close()
fmt.Printf("dumping db to file %q\n", outFile)
}
var w io.Writer = f
if filepath.Ext(outFile) == ".gz" {
gzip := gzip.NewWriter(f)
defer gzip.Close()
w = gzip
}
qr := graph.NewQuadReader(qs) //TODO: add possible support for exporting specific queries only
if typ == "quad" { // compatibility
typ = "nquads"
}
format := quad.FormatByName(typ)
if format == nil {
return fmt.Errorf("unknown format %q", typ)
} else if format.Writer == nil {
return fmt.Errorf("format %q: encoding is not supported", typ)
}
qw := format.Writer(w)
count, err := quad.Copy(qw, qr)
if err != nil {
qw.Close()
return err
}
if err = qw.Close(); err != nil {
return err
}
if outFile != "-" {
fmt.Printf("%d entries were written\n", count)
}
return nil
}
