33
44#include " nanoarrow/common/inline_types.h"
55#include " nanoarrow/hpp/unique.hpp"
6+ #include " nanoarrow/nanoarrow.hpp"
67#include " vortex/file.hpp"
78#include " vortex/scan.hpp"
9+ #include " vortex/write_options.hpp"
810#include < cassert>
11+ #include < cstdint>
12+ #include < filesystem>
913#include < iostream>
14+ #include < vector>
1015
11- int main (int argc, char *argv[]) {
12- if (argc != 2 ) {
13- std::cerr << " Usage: " 0 ] << " <vortex_file>" ' \n '
14- return 1 ;
16+ // / Create test data with structure {a: [10, 20, 30, 40, 50], b: [100, 200, 300, 400, 500]}
17+ ArrowArrayStream CreateTestDataStream () {
18+ // Create a simple two-column struct with int32 data
19+ // Schema: struct{a: int32, b: int32}
20+ nanoarrow::UniqueSchema schema;
21+ ArrowSchemaInit (schema.get ());
22+ NANOARROW_THROW_NOT_OK (ArrowSchemaSetType (schema.get (), NANOARROW_TYPE_STRUCT));
23+ NANOARROW_THROW_NOT_OK (ArrowSchemaAllocateChildren (schema.get (), 2 ));
24+ ArrowSchemaInit (schema->children [0 ]);
25+ ArrowSchemaInit (schema->children [1 ]);
26+ NANOARROW_THROW_NOT_OK (ArrowSchemaSetName (schema->children [0 ], " a"
27+ NANOARROW_THROW_NOT_OK (ArrowSchemaSetType (schema->children [0 ], NANOARROW_TYPE_INT32));
28+ NANOARROW_THROW_NOT_OK (ArrowSchemaSetName (schema->children [1 ], " b"
29+ NANOARROW_THROW_NOT_OK (ArrowSchemaSetType (schema->children [1 ], NANOARROW_TYPE_INT32));
30+
31+ // Create arrays for each field
32+ nanoarrow::UniqueArray field_a, field_b;
33+ NANOARROW_THROW_NOT_OK (ArrowArrayInitFromType (field_a.get (), NANOARROW_TYPE_INT32));
34+ NANOARROW_THROW_NOT_OK (ArrowArrayInitFromType (field_b.get (), NANOARROW_TYPE_INT32));
35+
36+ // Reserve for 5 elements
37+ NANOARROW_THROW_NOT_OK (ArrowArrayStartAppending (field_a.get ()));
38+ NANOARROW_THROW_NOT_OK (ArrowArrayStartAppending (field_b.get ()));
39+
40+ // Add data: a=[10, 20, 30, 40, 50], b=[100, 200, 300, 400, 500]
41+ std::vector<int32_t > data_a = {10 , 20 , 30 , 40 , 50 };
42+ std::vector<int32_t > data_b = {100 , 200 , 300 , 400 , 500 };
43+ for (size_t i = 0 ; i < data_a.size (); ++i) {
44+ NANOARROW_THROW_NOT_OK (ArrowArrayAppendInt (field_a.get (), data_a[i]));
45+ NANOARROW_THROW_NOT_OK (ArrowArrayAppendInt (field_b.get (), data_b[i]));
1546 }
16- std::string vortex_file = argv[1 ];
47+
48+ NANOARROW_THROW_NOT_OK (
49+ ArrowArrayFinishBuilding (field_a.get (), NANOARROW_VALIDATION_LEVEL_NONE, nullptr ));
50+ NANOARROW_THROW_NOT_OK (
51+ ArrowArrayFinishBuilding (field_b.get (), NANOARROW_VALIDATION_LEVEL_NONE, nullptr ));
52+
53+ // Create struct array
54+ nanoarrow::UniqueArray struct_array;
55+ NANOARROW_THROW_NOT_OK (ArrowArrayInitFromType (struct_array.get (), NANOARROW_TYPE_STRUCT));
56+ NANOARROW_THROW_NOT_OK (ArrowArrayAllocateChildren (struct_array.get (), 2 ));
57+ struct_array->length = 5 ;
58+ ArrowArrayMove (field_a.get (), struct_array->children [0 ]);
59+ ArrowArrayMove (field_b.get (), struct_array->children [1 ]);
60+
61+ // Create vector and move array into it
62+ std::vector<nanoarrow::UniqueArray> arrays;
63+ arrays.push_back (std::move (struct_array));
64+
65+ // Create stream
66+ ArrowArrayStream stream;
67+ nanoarrow::VectorArrayStream vector_stream (schema.get (), std::move (arrays));
68+ vector_stream.ToArrayStream (&stream);
69+
70+ return stream;
71+ }
72+
73+ int main () {
74+ // Create a temporary file path
75+ std::filesystem::path temp_dir = std::filesystem::temp_directory_path ();
76+ std::string vortex_file = (temp_dir / " hello_vortex_example.vortex" string ();
77+
78+ std::cout << " === Vortex C++ Example ===" ' \n '
79+ std::cout << " Writing to: " ' \n '
80+
81+ // Write test data to a Vortex file
82+ {
83+ auto stream = CreateTestDataStream ();
84+ vortex::VortexWriteOptions write_options;
85+ write_options.WriteArrayStream (stream, vortex_file);
86+ std::cout << " Wrote test data to file" ' \n '
87+ }
88+
1789 auto check_stream = [](ArrowArrayStream &stream) {
1890 nanoarrow::UniqueArray array;
1991 int get_next_result = stream.get_next (&stream, array.get ());
2092 assert (get_next_result == 0 );
2193 std::cout << " Number of rows: " length << ' \n '
2294 std::cout << " Number of columns in schema: " n_children << ' \n '
2395 };
96+
2497 // 1. Classic C++ builder pattern
98+ std::cout << " \n 1. Classic C++ builder pattern:" ' \n '
2599 {
26100 auto builder = vortex::VortexFile::Open (vortex_file).CreateScanBuilder ();
27101 builder.WithLimit (3 );
28102 auto stream = std::move (builder).IntoStream ();
29103 check_stream (stream);
30104 }
31105 // 2. One-line Rusty function chain
106+ std::cout << " \n 2. One-line Rusty function chain:" ' \n '
32107 {
33108 auto stream = vortex::VortexFile::Open (vortex_file).CreateScanBuilder ().WithLimit (3 ).IntoStream ();
34109 check_stream (stream);
35110 }
36111 // 3. Conditionally set the builder
112+ std::cout << " \n 3. Conditionally set the builder:" ' \n '
37113 {
38114 auto limit = 1 ;
39115 auto builder = vortex::VortexFile::Open (vortex_file).CreateScanBuilder ();
@@ -46,5 +122,10 @@ int main(int argc, char *argv[]) {
46122 auto stream = std::move (builder).IntoStream ();
47123 check_stream (stream);
48124 }
125+
126+ // Clean up
127+ std::filesystem::remove (vortex_file);
128+ std::cout << " \n Cleaned up temporary file" ' \n '
129+
49130 return 0 ;
50131}
0 commit comments