src/RecfileCommand.h
branchv_0
changeset 3 891fe13d7397
parent 2 2390e2949a36
child 4 b5239b4b345b
equal deleted inserted replaced
2:2390e2949a36 3:891fe13d7397
    19 
    19 
    20 #include <iostream>
    20 #include <iostream>
    21 #include <string>
    21 #include <string>
    22 #include <sstream>
    22 #include <sstream>
    23 #include <vector>
    23 #include <vector>
       
    24 #include <set>
    24 
    25 
    25 #include <relpipe/writer/typedefs.h>
    26 #include <relpipe/writer/typedefs.h>
       
    27 #include <relpipe/writer/RelationalWriter.h>
       
    28 #include <relpipe/writer/AttributeMetadata.h>
    26 
    29 
    27 namespace relpipe {
    30 namespace relpipe {
    28 namespace in {
    31 namespace in {
    29 namespace recfile {
    32 namespace recfile {
    30 
    33 
    42 	};
    45 	};
    43 
    46 
    44 	class RecfileHandler {
    47 	class RecfileHandler {
    45 	private:
    48 	private:
    46 		RelationalWriter* writer;
    49 		RelationalWriter* writer;
       
    50 		string_t currentRelationName;
       
    51 		std::vector<string_t> currentRecord;
       
    52 		std::vector<std::vector<string_t>> currentRecords;
       
    53 		size_t prefetchCount = 1;
       
    54 		bool headerWritten = false;
       
    55 
       
    56 		void writeHeader() {
       
    57 			if (headerWritten) return;
       
    58 
       
    59 			std::vector<AttributeMetadata> attributeMetadata;
       
    60 
       
    61 			// TODO: writer->startRelation(currentRelationName, attributeMetadata, true);
       
    62 
       
    63 			headerWritten = true;
       
    64 		}
       
    65 
       
    66 		void writeRecords() {
       
    67 			for (int i = 0; i < currentRecords.size(); i++) {
       
    68 				std::vector<string_t> record = currentRecords[i];
       
    69 				std::wcerr << L"record: " << std::endl;
       
    70 				for (int j = 0; j < record.size(); j += 2) {
       
    71 					std::wcerr << L"  '" << record[j] << L"': '" << record[j + 1] << L"'" << std::endl;
       
    72 					// TODO: writer->writeAttribute()
       
    73 				}
       
    74 			}
       
    75 			currentRecords.clear();
       
    76 		}
    47 
    77 
    48 		void metadata(const string_t& name, const string_t& value) {
    78 		void metadata(const string_t& name, const string_t& value) {
    49 			std::wcerr << L"metadata(" << name << L", " << value << L");" << std::endl; // TODO: remove debug
    79 			std::wcerr << L"metadata(" << name << L", " << value << L");" << std::endl; // TODO: remove debug
       
    80 
       
    81 			if (name == L"rec") {
       
    82 				currentRelationName = value;
       
    83 				currentRecord.clear();
       
    84 				currentRecords.clear();
       
    85 				headerWritten = false;
       
    86 			} else if (name == L"type") {
       
    87 				// TODO: save type hint
       
    88 			} else {
       
    89 				// ignore – other recfile metadata like keys or auto-increments
       
    90 			}
    50 		}
    91 		}
    51 
    92 
    52 		void data(const string_t& name, const string_t& value) {
    93 		void data(const string_t& name, const string_t& value) {
    53 			std::wcerr << L"data(" << name << L", " << value << L");" << std::endl; // TODO: remove debug
    94 			std::wcerr << L"data(" << name << L", " << value << L");" << std::endl; // TODO: remove debug
       
    95 			currentRecord.push_back(name);
       
    96 			currentRecord.push_back(value);
    54 		}
    97 		}
    55 
    98 
    56 		void comment(const string_t& value) {
    99 		void comment(const string_t& value) {
    57 			std::wcerr << L"comment(" << value << L");" << std::endl; // TODO: remove debug
   100 			// ignore comments
    58 		}
   101 		}
    59 
   102 
    60 		void separator() {
   103 		void separator() {
    61 			std::wcerr << L"separator()" << std::endl; // TODO: remove debug
   104 			std::wcerr << L"separator()" << std::endl; // TODO: remove debug
       
   105 			if (currentRecord.size()) {
       
   106 				currentRecords.push_back(currentRecord);
       
   107 				currentRecord.clear();
       
   108 			}
       
   109 
       
   110 			if (prefetchCount > 0 && currentRecords.size() >= prefetchCount) {
       
   111 				writeHeader();
       
   112 				writeRecords();
       
   113 			}
    62 		}
   114 		}
    63 
   115 
    64 		void end() {
   116 		void end() {
    65 			std::wcerr << L"end()" << std::endl; // TODO: remove debug
   117 			std::wcerr << L"end();" << std::endl; // TODO: remove debug
       
   118 			if (currentRecord.size()) currentRecords.push_back(currentRecord);
       
   119 			writeHeader();
       
   120 			writeRecords();
    66 		}
   121 		}
    67 
   122 
    68 	public:
   123 	public:
    69 
   124 
    70 		RecfileHandler(RelationalWriter* writer) : writer(writer) {
   125 		RecfileHandler(RelationalWriter* writer) : writer(writer) {
    72 
   127 
    73 		virtual ~RecfileHandler() {
   128 		virtual ~RecfileHandler() {
    74 		}
   129 		}
    75 
   130 
    76 		void logicalLine(RecfileLineType type, const string_t& name = L"", const string_t& value = L"") {
   131 		void logicalLine(RecfileLineType type, const string_t& name = L"", const string_t& value = L"") {
    77 			// TODO: writer->startRelation()
       
    78 			// TODO: writer->writeAttribute()
       
    79 			switch (type) {
   132 			switch (type) {
    80 				case RecfileLineType::METADATA: return metadata(name, value);
   133 				case RecfileLineType::METADATA: return metadata(name, value);
    81 				case RecfileLineType::DATA: return data(name, value);
   134 				case RecfileLineType::DATA: return data(name, value);
    82 				case RecfileLineType::COMMENT: return comment(value);
   135 				case RecfileLineType::COMMENT: return comment(value);
    83 				case RecfileLineType::SEPARATOR: return separator();
   136 				case RecfileLineType::SEPARATOR: return separator();