Esempio n. 1
0
func TestBooleanColumn(t *testing.T) {

	schema := parquet.NewSchema()

	//	fd := parquet.NewFile("tempfile", s)

	//	fd.Close()

	err := schema.AddColumnFromSpec("value: boolean REQUIRED")
	if err != nil {
		t.Fatal(err)
	}

	// tmpfile, err := ioutil.TempFile("", "test_parquet")
	// if err != nil {
	// 	t.Fatal(err)
	// }

	// defer os.Remove(tmpfile.Name()) // clean up

	var b bytes.Buffer

	enc := parquet.NewEncoder(schema, &b)

	values := genBool(100)
	if err := enc.WriteBool("value", values); err != nil {
		t.Fatal(err)
	}

	if err := enc.Close(); err != nil {
		t.Fatal(err)
	}

	fileName := "./boolean.parquet"

	if err := ioutil.WriteFile(fileName, b.Bytes(), os.ModePerm); err != nil {
		t.Fatal(err)
	}

	// // launch external implementation
	// cmd := exec.Command("./parquet_reader", fileName)
	// stdout, err := cmd.StdoutPipe()
	// if err != nil {
	// 	t.Fatal(err)
	// }

	// if err := cmd.Start(); err != nil {
	// 	t.Fatal(err)
	// }

	// io.Copy(os.Stdout, stdout)

	// if err := cmd.Wait(); err != nil {
	// 	log.Fatal(err)
	// }

	// if err := tmpfile.Close(); err != nil {
	// 	t.Fatal(err)
	// }

}
Esempio n. 2
0
func main() {
	fd, err := os.Create("temp.avro")
	if err != nil {
		log.Println("error", err)
	}

	makeSomeData(fd)

	fd.Close()

	fd, err = os.Open("temp.avro")
	if err != nil {
		log.Println("error", err)
	}

	//dumpReader(fd)

	fd.Close()

	record, err := goavro.NewRecord(goavro.RecordSchema(schema))
	if err != nil {
		log.Println("error", err)
	}
	{
		fd, err = os.Create("temp.parquet")
		if err != nil {
			log.Println("error", err)
		}

		pschema := parquet.NewSchema()

		for _, f := range record.Fields {

			fschema, err := record.GetFieldSchema(f.Name)
			if err != nil {
				panic(err)
			}

			err = pschema.AddColumnFromThriftSchema(fschema.(map[string]interface{}))
			if err != nil {
				panic(err)
			}
		}

		enc := parquet.NewEncoder(pschema, fd)

		// Read the file
		fd, err = os.Open("temp.avro")
		if err != nil {
			log.Println("error", err)
		}

		fr, err := goavro.NewReader(goavro.BufferFromReader(fd))
		if err != nil {
			log.Fatal("cannot create Reader: ", err)
		}

		defer func() {
			if err := fr.Close(); err != nil {
				log.Fatal(err)
			}
		}()

		for fr.Scan() {
			datum, err := fr.Read()
			if err != nil {
				log.Println("cannot read datum: ", err)
				continue
			}
			r, ok := datum.(*goavro.Record)
			if !ok {
				panic("expected goavro.Record")
			}

			rec := make(map[string]interface{})
			for _, field := range r.Fields {
				v, err := r.Get(field.Name)
				if err != nil {
					panic(err)
				}
				rec[field.Name] = v
			}

			err = enc.WriteRecords([]map[string]interface{}{rec})
			if err != nil {
				panic(err)
			}
		}

		if err := enc.Close(); err != nil {
			panic(err)
		}

		fd.Close()
	}

	log.Println("finished")
}