bool parse(const char * const name, __Matrix &matrix)
{
std::vector<double> row;
matrix.clear();
if (_fd == nullptr)
_fd = fopen(name, "r");
if (_fd == nullptr)
return false;
next();
while (!eof()) {
_buffer.clear();
parseNumber();
if (_buffer.size() > 0) {
row.push_back(atof(_buffer.c_str()));
}
if (isEndOfLine()) {
skipEndOfLine();
matrix.push_back(row);
row.clear();
}
}
if (row.size() > 0)
matrix.push_back(row);
fclose(_fd);
_fd = nullptr;
return true;
}
std::vector<std::vector<Type>> parse(const char * const name) {
std::vector<std::vector<Type>> matrix;
matrix.clear();
std::vector<Type> row;
if (_fd == nullptr)
_fd = fopen(name, "r");
if (_fd == nullptr)
return matrix;
next();
while (!eof()) {
_buffer.clear();
parseNumber();
if (_buffer.size() > 0) {
row.push_back(atof(_buffer.c_str()));
}
if (isEndOfLine()) {
skipEndOfLine();
matrix.push_back(row);
row.clear();
}
}
if (row.size() > 0)
matrix.push_back(row);
fclose(_fd);
_fd = nullptr;
return matrix;
}
static int
drainWhitespace(FILE *f, int c)
{
if (c == 0)
c = getc(f);
while (c > 0 && (c == '#' || c == ' ' || c == '\t')) {
if (c == '#') {
skipEndOfLine(f, c);
c = '\n';
break;
}
c = getc(f);
}
return (c > 0) ? c : 0;
}
void parseGoal(B& in, S& solver)
{
skipWhitespace(in);
if (!skipText(in, "min:")) return; // No goal specified. If file is syntactically correct, no characters will have been consumed (expecting integer).
vec<Lit> ps; vec<Int> Cs; vec<char> tmp;
skipWhitespace(in);
if (*in == ';'){
++in;
skipLine(in);
}else{
parseExpr(in, solver, ps, Cs, tmp);
skipWhitespace(in);
if (!skipText(in, ";")) throw xstrdup("Expecting ';' after goal function.");
}
skipEndOfLine(in);
solver.addGoal(ps, Cs);
}
bool parseConstrs(B& in, S& solver)
{
vec<Lit> ps; vec<Int> Cs; vec<char> tmp;
int ineq;
Int rhs;
while (*in != EOF){
parseExpr(in, solver, ps, Cs, tmp);
ineq = parseInequality(in);
rhs = parseInt(in);
skipWhitespace(in);
if (!skipText(in, ";")) throw xstrdup("Expecting ';' after constraint.");
skipEndOfLine(in);
if (!solver.addConstr(ps, Cs, rhs, ineq))
return false;
ps.clear();
Cs.clear();
}
return true;
}
/** gcc-7 generates wrong code with optimization level greater than 1.
* See tests: dbms/src/IO/tests/write_int.cpp
* and dbms/tests/queries/0_stateless/00898_parsing_bad_diagnostic_message.sh
* This is compiler bug. The bug does not present in gcc-8 and clang-8.
* Nevertheless, we don't need high optimization of this function.
*/
bool OPTIMIZE(1) CSVRowInputStream::parseRowAndPrintDiagnosticInfo(MutableColumns & columns,
WriteBuffer & out, size_t max_length_of_column_name, size_t max_length_of_data_type_name)
{
const char delimiter = format_settings.csv.delimiter;
for (size_t input_position = 0; input_position < column_indexes_for_input_fields.size(); ++input_position)
{
if (input_position == 0 && istr.eof())
{
out << "<End of stream>\n";
return false;
}
if (column_indexes_for_input_fields[input_position].has_value())
{
const auto & column_index = *column_indexes_for_input_fields[input_position];
const auto & current_column_type = data_types[column_index];
out << "Column " << input_position << ", " << std::string((input_position < 10 ? 2 : input_position < 100 ? 1 : 0), ' ')
<< "name: " << header.safeGetByPosition(column_index).name << ", " << std::string(max_length_of_column_name - header.safeGetByPosition(column_index).name.size(), ' ')
<< "type: " << current_column_type->getName() << ", " << std::string(max_length_of_data_type_name - current_column_type->getName().size(), ' ');
BufferBase::Position prev_position = istr.position();
BufferBase::Position curr_position = istr.position();
std::exception_ptr exception;
try
{
skipWhitespacesAndTabs(istr);
prev_position = istr.position();
current_column_type->deserializeAsTextCSV(*columns[column_index], istr, format_settings);
curr_position = istr.position();
skipWhitespacesAndTabs(istr);
}
catch (...)
{
exception = std::current_exception();
}
if (curr_position < prev_position)
throw Exception("Logical error: parsing is non-deterministic.", ErrorCodes::LOGICAL_ERROR);
if (isNumber(current_column_type) || isDateOrDateTime(current_column_type))
{
/// An empty string instead of a value.
if (curr_position == prev_position)
{
out << "ERROR: text ";
verbosePrintString(prev_position, std::min(prev_position + 10, istr.buffer().end()), out);
out << " is not like " << current_column_type->getName() << "\n";
return false;
}
}
out << "parsed text: ";
verbosePrintString(prev_position, curr_position, out);
if (exception)
{
if (current_column_type->getName() == "DateTime")
out << "ERROR: DateTime must be in YYYY-MM-DD hh:mm:ss or NNNNNNNNNN (unix timestamp, exactly 10 digits) format.\n";
else if (current_column_type->getName() == "Date")
out << "ERROR: Date must be in YYYY-MM-DD format.\n";
else
out << "ERROR\n";
return false;
}
out << "\n";
if (current_column_type->haveMaximumSizeOfValue())
{
if (*curr_position != '\n' && *curr_position != '\r' && *curr_position != delimiter)
{
out << "ERROR: garbage after " << current_column_type->getName() << ": ";
verbosePrintString(curr_position, std::min(curr_position + 10, istr.buffer().end()), out);
out << "\n";
if (current_column_type->getName() == "DateTime")
out << "ERROR: DateTime must be in YYYY-MM-DD hh:mm:ss or NNNNNNNNNN (unix timestamp, exactly 10 digits) format.\n";
else if (current_column_type->getName() == "Date")
out << "ERROR: Date must be in YYYY-MM-DD format.\n";
return false;
}
}
}
else
{
static const String skipped_column_str = "<SKIPPED COLUMN>";
out << "Column " << input_position << ", " << std::string((input_position < 10 ? 2 : input_position < 100 ? 1 : 0), ' ')
<< "name: " << skipped_column_str << ", " << std::string(max_length_of_column_name - skipped_column_str.length(), ' ')
<< "type: " << skipped_column_str << ", " << std::string(max_length_of_data_type_name - skipped_column_str.length(), ' ');
String tmp;
readCSVString(tmp, istr, format_settings.csv);
}
/// Delimiters
if (input_position + 1 == column_indexes_for_input_fields.size())
{
if (istr.eof())
return false;
/// we support the extra delimiter at the end of the line
if (*istr.position() == delimiter)
{
++istr.position();
if (istr.eof())
break;
}
if (!istr.eof() && *istr.position() != '\n' && *istr.position() != '\r')
{
out << "ERROR: There is no line feed. ";
verbosePrintString(istr.position(), istr.position() + 1, out);
out << " found instead.\n"
" It's like your file has more columns than expected.\n"
"And if your file have right number of columns, maybe it have unquoted string value with comma.\n";
return false;
}
skipEndOfLine(istr);
}
else
{
try
{
assertChar(delimiter, istr);
}
catch (const DB::Exception &)
{
if (*istr.position() == '\n' || *istr.position() == '\r')
{
out << "ERROR: Line feed found where delimiter (" << delimiter << ") is expected."
" It's like your file has less columns than expected.\n"
"And if your file have right number of columns, maybe it have unescaped quotes in values.\n";
}
else
{
out << "ERROR: There is no delimiter (" << delimiter << "). ";
verbosePrintString(istr.position(), istr.position() + 1, out);
out << " found instead.\n";
}
return false;
}
}
}
return true;
}
