// getExportOutput returns an implementation of ExportOutput which can handle
// transforming BSON documents into the appropriate output format and writing
// them to an output stream.
func (exp *MongoExport) getExportOutput(out io.Writer) (ExportOutput, error) {
if exp.OutputOpts.Type == CSV {
// TODO what if user specifies *both* --fields and --fieldFile?
var fields []string
var err error
if len(exp.OutputOpts.Fields) > 0 {
fields = strings.Split(exp.OutputOpts.Fields, ",")
} else if exp.OutputOpts.FieldFile != "" {
fields, err = util.GetFieldsFromFile(exp.OutputOpts.FieldFile)
if err != nil {
return nil, err
}
} else {
return nil, fmt.Errorf("CSV mode requires a field list")
}
exportFields := make([]string, 0, len(fields))
for _, field := range fields {
// for '$' field projections, exclude '.$' from the field name
if i := strings.LastIndex(field, "."); i != -1 && field[i+1:] == "$" {
exportFields = append(exportFields, field[:i])
} else {
exportFields = append(exportFields, field)
}
}
return NewCSVExportOutput(exportFields, out), nil
}
return NewJSONExportOutput(exp.OutputOpts.JSONArray, exp.OutputOpts.Pretty, out), nil
}
// getInputReader returns an implementation of InputReader based on the input type
func (imp *MongoImport) getInputReader(in io.Reader) (InputReader, error) {
var fields []string
var err error
if imp.InputOptions.Fields != nil {
fields = strings.Split(*imp.InputOptions.Fields, ",")
} else if imp.InputOptions.FieldFile != nil {
fields, err = util.GetFieldsFromFile(*imp.InputOptions.FieldFile)
if err != nil {
return nil, err
}
}
// header fields validation can only happen once we have an input reader
if !imp.InputOptions.HeaderLine {
if err = validateReaderFields(fields); err != nil {
return nil, err
}
}
if imp.InputOptions.Type == CSV {
return NewCSVInputReader(fields, in, imp.ToolOptions.NumDecodingWorkers), nil
} else if imp.InputOptions.Type == TSV {
return NewTSVInputReader(fields, in, imp.ToolOptions.NumDecodingWorkers), nil
}
return NewJSONInputReader(imp.InputOptions.JSONArray, in, imp.ToolOptions.NumDecodingWorkers), nil
}
//getExportOutput returns an implementation of ExportOutput which can handle
//transforming BSON documents into the appropriate output format and writing
//them to an output stream.
func (exp *MongoExport) getExportOutput(out io.Writer) (ExportOutput, error) {
if exp.OutputOpts.CSV {
//TODO what if user specifies *both* --fields and --fieldFile?
var fields []string
var err error
if len(exp.OutputOpts.Fields) > 0 {
fields = strings.Split(exp.OutputOpts.Fields, ",")
} else if exp.OutputOpts.FieldFile != "" {
fields, err = util.GetFieldsFromFile(exp.OutputOpts.FieldFile)
if err != nil {
return nil, err
}
}
return NewCSVExportOutput(fields, out), nil
}
return NewJSONExportOutput(exp.OutputOpts.JSONArray, out), nil
}
// getImportInput returns an implementation of ImportInput which can handle
// transforming tsv, csv, or JSON into appropriate BSON documents
func (mongoImport *MongoImport) getImportInput(in io.Reader) (ImportInput,
error) {
var fields []string
var err error
// there should be some sanity checks done for field names - e.g. that they
// don't contain dots
if len(mongoImport.InputOptions.Fields) != 0 {
fields = strings.Split(strings.Trim(mongoImport.InputOptions.Fields,
" "), ",")
} else if mongoImport.InputOptions.FieldFile != "" {
fields, err = util.GetFieldsFromFile(mongoImport.InputOptions.FieldFile)
if err != nil {
return nil, err
}
}
if mongoImport.InputOptions.Type == CSV {
return NewCSVImportInput(fields, in), nil
} else if mongoImport.InputOptions.Type == TSV {
return NewTSVImportInput(fields, in), nil
}
return NewJSONImportInput(mongoImport.InputOptions.JSONArray, in), nil
}
// getInputReader returns an implementation of InputReader based on the input type
func (imp *MongoImport) getInputReader(in io.Reader) (InputReader, error) {
var colSpecs []ColumnSpec
var headers []string
var err error
if imp.InputOptions.Fields != nil {
headers = splitInlineHeader(*imp.InputOptions.Fields)
} else if imp.InputOptions.FieldFile != nil {
headers, err = util.GetFieldsFromFile(*imp.InputOptions.FieldFile)
if err != nil {
return nil, err
}
}
if imp.InputOptions.ColumnsHaveTypes {
colSpecs, err = ParseTypedHeaders(headers, ParsePG(imp.InputOptions.ParseGrace))
if err != nil {
return nil, err
}
} else {
colSpecs = ParseAutoHeaders(headers)
}
// header fields validation can only happen once we have an input reader
if !imp.InputOptions.HeaderLine {
if err = validateReaderFields(ColumnNames(colSpecs)); err != nil {
return nil, err
}
}
out := os.Stdout
ignoreBlanks := imp.IngestOptions.IgnoreBlanks && imp.InputOptions.Type != JSON
if imp.InputOptions.Type == CSV {
return NewCSVInputReader(colSpecs, in, out, imp.IngestOptions.NumDecodingWorkers, ignoreBlanks), nil
} else if imp.InputOptions.Type == TSV {
return NewTSVInputReader(colSpecs, in, out, imp.IngestOptions.NumDecodingWorkers, ignoreBlanks), nil
}
return NewJSONInputReader(imp.InputOptions.JSONArray, in, imp.IngestOptions.NumDecodingWorkers), nil
}