int QuotedPrintableDecoderBuf::readFromDevice()
{
int ch = _buf.sbumpc();
while (ch == '=')
{
ch = _buf.sbumpc();
if (ch == '\r')
{
ch = _buf.sbumpc(); // read \n
}
else if (Poco::Ascii::isHexDigit(ch))
{
std::string hex;
hex += (char) ch;
ch = _buf.sbumpc();
if (Poco::Ascii::isHexDigit(ch))
{
hex += (char) ch;
return NumberParser::parseHex(hex);
}
throw DataFormatException("Incomplete hex number in quoted-printable encoded stream");
}
else if (ch != '\n')
{
throw DataFormatException("Invalid occurrence of '=' in quoted-printable encoded stream");
}
ch = _buf.sbumpc();
}
return ch;
}
Var Var::parseObject(const std::string& val, std::string::size_type& pos)
{
poco_assert_dbg (val[pos] == '{');
++pos;
skipWhiteSpace(val, pos);
DynamicStruct aStruct;
while (val[pos] != '}' && pos < val.size())
{
std::string key = parseString(val, pos);
skipWhiteSpace(val, pos);
if (val[pos] != ':')
throw DataFormatException("Incorrect object, must contain: key : value pairs");
++pos; // skip past :
Var value = parse(val, pos);
aStruct.insert(key, value);
skipWhiteSpace(val, pos);
if (val[pos] == ',')
{
++pos;
skipWhiteSpace(val, pos);
}
}
if (val[pos] != '}')
throw DataFormatException("Unterminated object");
++pos;
return aStruct;
}
std::string Var::parseString(const std::string& val, std::string::size_type& pos)
{
static const std::string STR_STOP("\"");
static const std::string OTHER_STOP(" ,]}"); // we stop at space, ',', ']' or '}'
bool inString = false;
//skip optional ' "
if (val[pos] == '"')
{
inString = true;
++pos;
}
std::string::size_type stop = std::string::npos;
if (inString)
{
stop = val.find_first_of(STR_STOP, pos);
if (stop == std::string::npos)
throw DataFormatException("Unterminated string");
}
else
{
// we stop at space, ',', ']' or '}' or end of string
stop = val.find_first_of(OTHER_STOP, pos);
if (stop == std::string::npos)
stop = val.size();
std::string::size_type safeCheck = val.find_first_of(STR_STOP, pos);
if (safeCheck != std::string::npos && safeCheck < stop)
throw DataFormatException("Misplaced string termination char found");
}
// stop now points to the last char to be not included
std::string result = val.substr(pos, stop - pos);
++stop; // point past '/"
pos = stop;
return result;
}
void Preparation::prepare(std::size_t pos, const Poco::Any&)
{
ODBCColumn col(_rStmt, pos);
switch (col.type())
{
case MetaColumn::FDT_INT8:
return preparePOD<Poco::Int8>(pos, SQL_C_STINYINT);
case MetaColumn::FDT_UINT8:
return preparePOD<Poco::UInt8>(pos, SQL_C_UTINYINT);
case MetaColumn::FDT_INT16:
return preparePOD<Poco::Int16>(pos, SQL_C_SSHORT);
case MetaColumn::FDT_UINT16:
return preparePOD<Poco::UInt16>(pos, SQL_C_USHORT);
case MetaColumn::FDT_INT32:
return preparePOD<Poco::Int32>(pos, SQL_C_SLONG);
case MetaColumn::FDT_UINT32:
return preparePOD<Poco::UInt32>(pos, SQL_C_ULONG);
case MetaColumn::FDT_INT64:
return preparePOD<Poco::Int64>(pos, SQL_C_SBIGINT);
case MetaColumn::FDT_UINT64:
return preparePOD<Poco::UInt64>(pos, SQL_C_UBIGINT);
case MetaColumn::FDT_BOOL:
return preparePOD<bool>(pos, SQL_C_BIT);
case MetaColumn::FDT_FLOAT:
return preparePOD<float>(pos, SQL_C_FLOAT);
case MetaColumn::FDT_DOUBLE:
return preparePOD<float>(pos, SQL_C_DOUBLE);
case MetaColumn::FDT_STRING:
return prepareRaw(pos, SQL_C_CHAR, maxDataSize(pos));
case MetaColumn::FDT_BLOB:
return prepareRaw(pos, SQL_C_BINARY, maxDataSize(pos));
default:
throw DataFormatException("Unsupported data type.");
}
prepareRaw(pos, SQL_C_BINARY, maxDataSize(pos));
}
int HexBinaryDecoderBuf::readFromDevice()
{
int c;
int n;
if ((n = readOne()) == -1) return -1;
if (n >= '0' && n <= '9')
c = n - '0';
else if (n >= 'A' && n <= 'F')
c = n - 'A' + 10;
else if (n >= 'a' && n <= 'f')
c = n - 'a' + 10;
else throw DataFormatException();
c <<= 4;
if ((n = readOne()) == -1) throw DataFormatException();
if (n >= '0' && n <= '9')
c |= n - '0';
else if (n >= 'A' && n <= 'F')
c |= n - 'A' + 10;
else if (n >= 'a' && n <= 'f')
c |= n - 'a' + 10;
else throw DataFormatException();
return c;
}
Var Var::parseArray(const std::string& val, std::string::size_type& pos)
{
poco_assert_dbg (val[pos] == '[');
++pos;
skipWhiteSpace(val, pos);
std::vector<Var> result;
while (val[pos] != ']' && pos < val.size())
{
result.push_back(parse(val, pos));
skipWhiteSpace(val, pos);
if (val[pos] == ',')
{
++pos;
skipWhiteSpace(val, pos);
}
}
if (val[pos] != ']')
throw DataFormatException("Unterminated array");
++pos;
return result;
}
void invalid_hex_char(unsigned char ch, const char* func)
{
string_appender<> oss;
oss << "invalid hex char(ch=" << char(ch) << ",ascii=" << int(ch) << ") in func: " << func;
throw DataFormatException(oss.str());
}
GroupCovers::GroupCovers(const vector<string>& groupFileNames, const char* groupElementSeparator, const char* groupDimensionElementsSeparator, const vector<unsigned int>& cardinalities, const vector<unordered_map<string, unsigned int>>& labels2Ids, const vector<unsigned int>& dimensionOrder): minCovers(), maxCovers()
{
const char_separator<char> elementSeparator(groupElementSeparator);
const char_separator<char> dimensionElementsSeparator(groupDimensionElementsSeparator);
const unsigned int n = cardinalities.size();
minCovers.resize(groupFileNames.size());
maxCovers.reserve(groupFileNames.size());
groups.resize(groupFileNames.size());
vector<vector<dynamic_bitset<>>>::iterator groupIt = groups.begin();
for (const string& fileName : groupFileNames)
{
ifstream file(fileName.c_str());
if (!file)
{
throw NoFileException(fileName.c_str());
}
groupIt->reserve(n);
for (const unsigned int cardinality : cardinalities)
{
groupIt->push_back(dynamic_bitset<>(cardinality));
}
unsigned int lineNb = 0;
while (!file.eof())
{
++lineNb;
string dataString;
getline(file, dataString);
#ifdef VERBOSE_PARSER
cout << fileName << ':' << lineNb << ": " << dataString << endl;
#endif
tokenizer<char_separator<char>> dimensionElements(dataString, dimensionElementsSeparator);
tokenizer<char_separator<char>>::const_iterator dimensionElementsIt = dimensionElements.begin();
if (dimensionElementsIt != dimensionElements.end())
{
try
{
const unsigned int dimensionId = lexical_cast<unsigned int>(*dimensionElementsIt);
if (dimensionId >= n)
{
throw DataFormatException(fileName.c_str(), lineNb, ("dimension " + lexical_cast<string>(dimensionId) + " does not exist! (at most " + lexical_cast<string>(n - 1) + " expected)").c_str());
}
if (++dimensionElementsIt != dimensionElements.end())
{
const unsigned int internalDimensionId = dimensionOrder[dimensionId];
dynamic_bitset<>& view = (*groupIt)[internalDimensionId];
const unordered_map<string, unsigned int>& labels2IdsView = labels2Ids[internalDimensionId];
tokenizer<char_separator<char>> elements(*dimensionElementsIt, elementSeparator);
for (const string& element : elements)
{
const unordered_map<string, unsigned int>::const_iterator labels2IdsViewIt = labels2IdsView.find(element);
if (labels2IdsViewIt == labels2IdsView.end())
{
cerr << "Warning: ignoring " << element << " at line " << lineNb << " of " << fileName << " because it is absent from dimension " << dimensionId << " of the input data" << endl;
}
else
{
if (labels2IdsViewIt->second != numeric_limits<unsigned int>::max())
{
view.set(labels2IdsViewIt->second);
}
}
}
}
}
catch (bad_lexical_cast &)
{
throw DataFormatException(fileName.c_str(), lineNb, ("the dimension should be an integer between 0 and " + lexical_cast<string>(n - 1) + '!').c_str());
}
if (++dimensionElementsIt != dimensionElements.end())
{
throw DataFormatException(fileName.c_str(), lineNb, "more than a pair (dimension, elements)!");
}
}
}
file.close();
unsigned int size = 0;
for (const dynamic_bitset<>& dimension : *groupIt)
{
size += dimension.count();
}
maxCovers.push_back(size);
++groupIt;
}
}
void ODBCMetaColumn::init()
{
getDescription();
if (Utility::isError(Poco::Data::ODBC::SQLColAttribute(_rStmt,
(SQLUSMALLINT) position() + 1, // ODBC columns are 1-based
SQL_DESC_LENGTH,
0,
0,
0,
&_dataLength)))
{
throw StatementException(_rStmt);
}
setName(std::string((char*) _columnDesc.name));
setLength(_columnDesc.size);
setPrecision(_columnDesc.decimalDigits);
setNullable(SQL_NULLABLE == _columnDesc.isNullable);
switch(_columnDesc.dataType)
{
case SQL_BIT:
setType(MetaColumn::FDT_BOOL); break;
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_LONGVARCHAR:
case -9:// SQL Server NVARCHAR
case -10:// PostgreSQL VARCHAR (without size specified)
setType(MetaColumn::FDT_STRING); break;
case SQL_TINYINT:
setType(MetaColumn::FDT_INT8); break;
case SQL_SMALLINT:
setType(MetaColumn::FDT_INT16); break;
case SQL_INTEGER:
setType(MetaColumn::FDT_INT32); break;
case SQL_BIGINT:
setType(MetaColumn::FDT_INT64); break;
case SQL_DOUBLE:
case SQL_FLOAT:
setType(MetaColumn::FDT_DOUBLE); break;
case SQL_NUMERIC:
case SQL_DECIMAL:
if (0 == _columnDesc.decimalDigits)
setType(MetaColumn::FDT_INT32);
else
setType(MetaColumn::FDT_DOUBLE);
break;
case SQL_REAL:
setType(MetaColumn::FDT_FLOAT); break;
case SQL_BINARY:
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
case -98:// IBM DB2 non-standard type
setType(MetaColumn::FDT_BLOB); break;
case SQL_TYPE_DATE:
setType(MetaColumn::FDT_DATE); break;
case SQL_TYPE_TIME:
setType(MetaColumn::FDT_TIME); break;
case SQL_TYPE_TIMESTAMP:
setType(MetaColumn::FDT_TIMESTAMP); break;
default:
throw DataFormatException("Unsupported data type.");
}
}
