1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include "avro.h"
#include "avro_private.h"
#include <stdio.h>
#include <stdlib.h>
static const char *schema_json =
"{"
" \"type\": \"record\","
" \"name\": \"test\","
" \"fields\": ["
" { \"name\": \"i\", \"type\": \"int\" },"
" { \"name\": \"l\", \"type\": \"long\" },"
" { \"name\": \"s\", \"type\": \"string\" },"
" {"
" \"name\": \"subrec\","
" \"type\": {"
" \"type\": \"record\","
" \"name\": \"sub\","
" \"fields\": ["
" { \"name\": \"f\", \"type\": \"float\" },"
" { \"name\": \"d\", \"type\": \"double\" }"
" ]"
" }"
" }"
" ]"
"}";
static void
populate_complex_record(avro_value_t *p_val)
{
avro_value_t field;
avro_value_get_by_index(p_val, 0, &field, NULL);
avro_value_set_int(&field, 42);
avro_value_get_by_index(p_val, 1, &field, NULL);
avro_value_set_long(&field, 4242);
avro_wrapped_buffer_t wbuf;
avro_wrapped_buffer_new_string(&wbuf, "Follow your bliss.");
avro_value_get_by_index(p_val, 2, &field, NULL);
avro_value_give_string_len(&field, &wbuf);
avro_value_t subrec;
avro_value_get_by_index(p_val, 3, &subrec, NULL);
avro_value_get_by_index(&subrec, 0, &field, NULL);
avro_value_set_float(&field, 3.14159265);
avro_value_get_by_index(&subrec, 1, &field, NULL);
avro_value_set_double(&field, 2.71828183);
}
int main(void)
{
int rval = 0;
size_t len;
static char buf[4096];
avro_writer_t writer;
avro_file_writer_t file_writer;
avro_file_reader_t file_reader;
const char *outpath = "test-1379.avro";
avro_schema_t schema = NULL;
avro_schema_error_t error = NULL;
check(rval, avro_schema_from_json(schema_json, strlen(schema_json), &schema, &error));
avro_value_iface_t *iface = avro_generic_class_from_schema(schema);
avro_value_t val;
avro_generic_value_new(iface, &val);
avro_value_t out;
avro_generic_value_new(iface, &out);
/* create the val */
avro_value_reset(&val);
populate_complex_record(&val);
/* create the writers */
writer = avro_writer_memory(buf, sizeof(buf));
check(rval, avro_file_writer_create(outpath, schema, &file_writer));
fprintf(stderr, "Writing to buffer\n");
check(rval, avro_value_write(writer, &val));
fprintf(stderr, "Writing buffer to %s "
"using avro_file_writer_append_encoded()\n", outpath);
len = avro_writer_tell(writer);
check(rval, avro_file_writer_append_encoded(file_writer, buf, len));
check(rval, avro_file_writer_close(file_writer));
check(rval, avro_file_reader(outpath, &file_reader));
fprintf(stderr, "Re-reading value to verify\n");
check(rval, avro_file_reader_read_value(file_reader, &out));
fprintf(stderr, "Verifying value...");
if (!avro_value_equal(&val, &out)) {
fprintf(stderr, "fail!\n");
exit(EXIT_FAILURE);
}
fprintf(stderr, "ok\n");
check(rval, avro_file_reader_close(file_reader));
remove(outpath);
avro_writer_free(writer);
avro_value_decref(&out);
avro_value_decref(&val);
avro_value_iface_decref(iface);
avro_schema_decref(schema);
exit(EXIT_SUCCESS);
}
|
