static int test_int64(void)
{
int i;
avro_schema_t writer_schema = avro_schema_long();
avro_schema_t float_schema = avro_schema_float();
avro_schema_t double_schema = avro_schema_double();
for (i = 0; i < 100; i++) {
int64_t value = rand_int64();
avro_datum_t datum = avro_int64(value);
avro_datum_t float_datum = avro_float(value);
avro_datum_t double_datum = avro_double(value);
write_read_check(writer_schema, datum, NULL, NULL, "long");
write_read_check(writer_schema, datum,
float_schema, float_datum, "long->float");
write_read_check(writer_schema, datum,
double_schema, double_datum, "long->double");
avro_datum_decref(datum);
avro_datum_decref(float_datum);
avro_datum_decref(double_datum);
}
avro_datum_t datum = avro_int64(10000);
test_json(datum, "10000");
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
avro_schema_decref(float_schema);
avro_schema_decref(double_schema);
return 0;
}
static int test_map(void)
{
avro_schema_t schema = avro_schema_map(avro_schema_long());
avro_datum_t datum = avro_map(schema);
int64_t i = 0;
char *nums[] =
{ "zero", "one", "two", "three", "four", "five", "six", NULL };
while (nums[i]) {
avro_datum_t i_datum = avro_int64(i);
avro_map_set(datum, nums[i], i_datum);
avro_datum_decref(i_datum);
i++;
}
if (avro_array_size(datum) != 7) {
fprintf(stderr, "Unexpected map size\n");
exit(EXIT_FAILURE);
}
avro_datum_t value;
const char *key;
avro_map_get_key(datum, 2, &key);
avro_map_get(datum, key, &value);
int64_t val;
avro_int64_get(value, &val);
if (val != 2) {
fprintf(stderr, "Unexpected map value 2\n");
exit(EXIT_FAILURE);
}
int index;
if (avro_map_get_index(datum, "two", &index)) {
fprintf(stderr, "Can't get index for key \"two\": %s\n",
avro_strerror());
exit(EXIT_FAILURE);
}
if (index != 2) {
fprintf(stderr, "Unexpected index for key \"two\"\n");
exit(EXIT_FAILURE);
}
if (!avro_map_get_index(datum, "foobar", &index)) {
fprintf(stderr, "Unexpected index for key \"foobar\"\n");
exit(EXIT_FAILURE);
}
write_read_check(schema, datum, NULL, NULL, "map");
test_json(datum,
"{\"zero\": 0, \"one\": 1, \"two\": 2, \"three\": 3, "
"\"four\": 4, \"five\": 5, \"six\": 6}");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int test_int64(void)
{
int i;
avro_schema_t writer_schema = avro_schema_long();
for (i = 0; i < 100; i++) {
avro_datum_t datum = avro_int64(rand_int64());
write_read_check(writer_schema, NULL, datum, "long");
avro_datum_decref(datum);
}
avro_schema_decref(writer_schema);
return 0;
}
static int test_map(void)
{
avro_schema_t schema = avro_schema_map(avro_schema_long());
avro_datum_t datum = avro_map();
int64_t i = 0;
char *nums[] =
{ "zero", "one", "two", "three", "four", "five", "six", NULL };
while (nums[i]) {
avro_datum_t i_datum = avro_int64(i);
avro_map_set(datum, nums[i], i_datum);
avro_datum_decref(i_datum);
i++;
}
write_read_check(schema, NULL, datum, "map");
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
/*添加学生记录*/
void add_student(avro_file_writer_t db, const char *name, const char *dept, const char *phone, int32_t age)
{
avro_datum_t student = avro_record("Student", NULL);
avro_datum_t sid_datum = avro_int64(++id);
avro_datum_t name_datum = avro_string(name);
avro_datum_t dept_datum = avro_string(dept);
avro_datum_t age_datum = avro_int32(age);
avro_datum_t phone_datum = avro_string(phone);
/*创建学生记录*/
if (avro_record_set(student, "SID", sid_datum)
|| avro_record_set(student, "Name", name_datum)
|| avro_record_set(student, "Dept", dept_datum)
|| avro_record_set(student, "Age", age_datum)
|| avro_record_set(student, "Phone", phone_datum)) {
fprintf(stderr, "Failed to create student datum structure");
exit(EXIT_FAILURE);
}
/*将记录添加到数据库文件中*/
if (avro_file_writer_append(db, student)) {
fprintf(stderr, "Failed to add student datum to database");
exit(EXIT_FAILURE);
}
/*解除引用，释放内存空间*/
avro_datum_decref(sid_datum);
avro_datum_decref(name_datum);
avro_datum_decref(dept_datum);
avro_datum_decref(age_datum);
avro_datum_decref(phone_datum);
avro_datum_decref(student);
fprintf(stdout, "Successfully added %s\n", name);
}
avro_datum_t avro_datum_from_schema(const avro_schema_t schema)
{
check_param(NULL, is_avro_schema(schema), "schema");
switch (avro_typeof(schema)) {
case AVRO_STRING:
return avro_givestring("", NULL);
case AVRO_BYTES:
return avro_givebytes("", 0, NULL);
case AVRO_INT32:
return avro_int32(0);
case AVRO_INT64:
return avro_int64(0);
case AVRO_FLOAT:
return avro_float(0);
case AVRO_DOUBLE:
return avro_double(0);
case AVRO_BOOLEAN:
return avro_boolean(0);
case AVRO_NULL:
return avro_null();
case AVRO_RECORD:
{
const struct avro_record_schema_t *record_schema =
avro_schema_to_record(schema);
avro_datum_t rec = avro_record(schema);
int i;
for (i = 0; i < record_schema->fields->num_entries; i++) {
union {
st_data_t data;
struct avro_record_field_t *field;
} val;
st_lookup(record_schema->fields, i, &val.data);
avro_datum_t field =
avro_datum_from_schema(val.field->type);
avro_record_set(rec, val.field->name, field);
avro_datum_decref(field);
}
return rec;
}
case AVRO_ENUM:
return avro_enum(schema, 0);
case AVRO_FIXED:
{
const struct avro_fixed_schema_t *fixed_schema =
avro_schema_to_fixed(schema);
return avro_givefixed(schema, NULL, fixed_schema->size, NULL);
}
case AVRO_MAP:
return avro_map(schema);
case AVRO_ARRAY:
return avro_array(schema);
case AVRO_UNION:
return avro_union(schema, -1, NULL);
case AVRO_LINK:
{
const struct avro_link_schema_t *link_schema =
avro_schema_to_link(schema);
return avro_datum_from_schema(link_schema->to);
}
default:
avro_set_error("Unknown schema type");
return NULL;
}
}
int main(int argc, char *argv[])
{
int rval;
avro_file_writer_t file_writer;
avro_file_reader_t file_reader;
char outpath[128];
FILE *fp;
char jsontext[16 * 1024];
avro_schema_t schema;
avro_schema_error_t schema_error;
avro_datum_t interop;
avro_datum_t array_datum;
avro_datum_t node_datum;
avro_datum_t union_datum;
avro_datum_t out_datum;
enum Kind {
KIND_A,
KIND_B,
KIND_C
};
if (argc != 3) {
exit(EXIT_FAILURE);
}
snprintf(outpath, sizeof(outpath), "%s/c.avro", argv[2]);
fprintf(stderr, "Writing to %s\n", outpath);
fp = fopen(argv[1], "r");
rval = fread(jsontext, 1, sizeof(jsontext) - 1, fp);
jsontext[rval] = '\0';
check(rval,
avro_schema_from_json(jsontext, rval, &schema, &schema_error));
check(rval, avro_file_writer_create(outpath, schema, &file_writer));
/* TODO: create a method for generating random data from schema */
interop = avro_record("Interop", "org.apache.avro");
avro_record_set(interop, "intField", avro_int32(42));
avro_record_set(interop, "longField", avro_int64(4242));
avro_record_set(interop, "stringField",
avro_wrapstring("Follow your bliss."));
avro_record_set(interop, "boolField", avro_boolean(1));
avro_record_set(interop, "floatField", avro_float(3.14159265));
avro_record_set(interop, "doubleField", avro_double(2.71828183));
avro_record_set(interop, "bytesField", avro_bytes("abcd", 4));
avro_record_set(interop, "nullField", avro_null());
array_datum = avro_array();
avro_array_append_datum(array_datum, avro_double(1.0));
avro_array_append_datum(array_datum, avro_double(2.0));
avro_array_append_datum(array_datum, avro_double(3.0));
avro_record_set(interop, "arrayField", array_datum);
avro_record_set(interop, "mapField", avro_map());
union_datum = avro_union(1, avro_double(1.61803399));
avro_record_set(interop, "unionField", union_datum);
avro_record_set(interop, "enumField", avro_enum("Kind", KIND_A));
avro_record_set(interop, "fixedField",
avro_fixed("MD5", "1234567890123456", 16));
node_datum = avro_record("Node", NULL);
avro_record_set(node_datum, "label",
avro_wrapstring("If you label me, you negate me."));
avro_record_set(node_datum, "children", avro_array());
avro_record_set(interop, "recordField", node_datum);
rval = avro_file_writer_append(file_writer, interop);
if (rval) {
fprintf(stderr, "Unable to append data to interop file!\n");
exit(EXIT_FAILURE);
} else {
fprintf(stderr, "Successfully appended datum to file\n");
}
check(rval, avro_file_writer_close(file_writer));
fprintf(stderr, "Closed writer.\n");
check(rval, avro_file_reader(outpath, &file_reader));
fprintf(stderr, "Re-reading datum to verify\n");
check(rval, avro_file_reader_read(file_reader, NULL, &out_datum));
fprintf(stderr, "Verifying datum...");
if (!avro_datum_equal(interop, out_datum)) {
fprintf(stderr, "fail!\n");
exit(EXIT_FAILURE);
}
fprintf(stderr, "ok\n");
check(rval, avro_file_reader_close(file_reader));
fprintf(stderr, "Closed reader.\n");
return 0;
}
