QByteArray Html5App::generateFileExtended(int fileType,
bool *versionAndCheckSum, QString *comment, QString *errorMessage) const
{
QByteArray data;
switch (fileType) {
case Html5AppGeneratedFileInfo::MainHtmlFile:
data = readBlob(path(MainHtmlOrigin), errorMessage);
break;
case Html5AppGeneratedFileInfo::AppViewerPriFile:
data = readBlob(path(AppViewerPriOrigin), errorMessage);
data.append(readBlob(path(DeploymentPriOrigin), errorMessage));
*comment = ProFileComment;
*versionAndCheckSum = true;
break;
case Html5AppGeneratedFileInfo::AppViewerCppFile:
data = appViewerCppFileCode(errorMessage);
*versionAndCheckSum = true;
break;
case Html5AppGeneratedFileInfo::AppViewerHFile:
default:
data = readBlob(path(AppViewerHOrigin), errorMessage);
*versionAndCheckSum = true;
break;
}
return data;
}
inline bool PBFParser::ReadHeader() {
_ThreadData initData;
/** read Header */
if(!readPBFBlobHeader(input, &initData)) {
return false;
}
if(readBlob(input, &initData)) {
if(!initData.PBFHeaderBlock.ParseFromArray(&(initData.charBuffer[0]), initData.charBuffer.size() ) ) {
std::cerr << "[error] Header not parseable!" << std::endl;
return false;
}
for(int i = 0, featureSize = initData.PBFHeaderBlock.required_features_size(); i < featureSize; ++i) {
const std::string& feature = initData.PBFHeaderBlock.required_features( i );
bool supported = false;
if ( "OsmSchema-V0.6" == feature ) {
supported = true;
}
else if ( "DenseNodes" == feature ) {
supported = true;
}
if ( !supported ) {
std::cerr << "[error] required feature not supported: " << feature.data() << std::endl;
return false;
}
}
} else {
std::cerr << "[error] blob not loaded!" << std::endl;
}
return true;
}
bool PBFParser::readNextBlock(std::fstream &stream, ParserThreadData *thread_data)
{
if (stream.eof())
{
return false;
}
if (!readPBFBlobHeader(stream, thread_data))
{
return false;
}
if (thread_data->PBFBlobHeader.type() != "OSMData")
{
return false;
}
if (!readBlob(stream, thread_data))
{
return false;
}
if (!thread_data->PBFprimitiveBlock.ParseFromArray(&(thread_data->charBuffer[0]),
thread_data->charBuffer.size()))
{
std::cerr << "failed to parse PrimitiveBlock" << std::endl;
return false;
}
return true;
}
//! reads checks info from database
void Table::loadCheckConstraints()
{
if (checkConstraintsLoadedM)
return;
checkConstraintsM.clear();
DatabasePtr db = getDatabase();
wxMBConv* conv = db->getCharsetConverter();
MetadataLoader* loader = db->getMetadataLoader();
// first start a transaction for metadata loading, then lock the table
// when objects go out of scope and are destroyed, table will be unlocked
// before the transaction is committed - any update() calls on observers
// can possibly use the same transaction
MetadataLoaderTransaction tr(loader);
SubjectLocker lock(this);
IBPP::Statement& st1 = loader->getStatement(
"select r.rdb$constraint_name, t.rdb$trigger_source, d.rdb$field_name "
" from rdb$relation_constraints r "
" join rdb$check_constraints c on r.rdb$constraint_name=c.rdb$constraint_name and r.rdb$constraint_type = 'CHECK'"
" join rdb$triggers t on c.rdb$trigger_name=t.rdb$trigger_name and t.rdb$trigger_type = 1 "
" left join rdb$dependencies d on t.rdb$trigger_name = d.rdb$dependent_name "
" and d.rdb$depended_on_name = r.rdb$relation_name "
" and d.rdb$depended_on_type = 0 "
" where r.rdb$relation_name=? "
" order by 1 "
);
st1->Set(1, wx2std(getName_(), conv));
st1->Execute();
CheckConstraint *cc = 0;
while (st1->Fetch())
{
std::string s;
st1->Get(1, s);
wxString cname(std2wxIdentifier(s, conv));
if (!cc || cname != cc->getName_()) // new constraint
{
wxString source;
readBlob(st1, 2, source, conv);
CheckConstraint c;
c.setParent(this);
c.setName_(cname);
c.sourceM = source;
checkConstraintsM.push_back(c);
cc = &checkConstraintsM.back();
}
if (!st1->IsNull(3))
{
st1->Get(3, s);
wxString fname(std2wxIdentifier(s, conv));
cc->columnsM.push_back(fname);
}
}
checkConstraintsLoadedM = true;
}
int
main(int argc, char **argv)
{
SQLRETURN RetCode;
SQLHSTMT old_odbc_stmt = SQL_NULL_HSTMT;
int i;
int key;
SQLLEN vind0;
int cnt = 2, wide;
char sql[256];
test_info *t = NULL;
odbc_use_version3 = 1;
odbc_connect();
/* tests (W)CHAR/BINARY -> (W)CHAR/BINARY (9 cases) */
add_test(SQL_C_BINARY, SQL_LONGVARCHAR, "TEXT", 123, 1 );
add_test(SQL_C_BINARY, SQL_LONGVARBINARY, "IMAGE", 987, 25);
add_test(SQL_C_CHAR, SQL_LONGVARBINARY, "IMAGE", 987, 25);
add_test(SQL_C_CHAR, SQL_LONGVARCHAR, "TEXT", 343, 47);
add_test(SQL_C_WCHAR, SQL_LONGVARBINARY, "IMAGE", 561, 29);
add_test(SQL_C_WCHAR, SQL_LONGVARCHAR, "TEXT", 698, 24);
if (odbc_db_is_microsoft()) {
add_test(SQL_C_BINARY, SQL_WLONGVARCHAR, "NTEXT", 765, 12);
add_test(SQL_C_CHAR, SQL_WLONGVARCHAR, "NTEXT", 237, 71);
add_test(SQL_C_WCHAR, SQL_WLONGVARCHAR, "NTEXT", 687, 68);
}
strcpy(sql, "CREATE TABLE #tt(k INT");
for (t = test_infos; t < test_infos+num_tests; ++t)
sprintf(strchr(sql, 0), ",f%u %s", t->num, t->db_type);
strcat(sql, ",v INT)");
odbc_command(sql);
old_odbc_stmt = odbc_stmt;
odbc_stmt = SQL_NULL_HSTMT;
/* Insert rows ... */
for (i = 0; i < cnt; i++) {
/* MS do not save correctly char -> binary */
if (!odbc_driver_is_freetds() && i)
continue;
CHKAllocHandle(SQL_HANDLE_STMT, odbc_conn, &odbc_stmt, "S");
strcpy(sql, "INSERT INTO #tt VALUES(?");
for (t = test_infos; t < test_infos+num_tests; ++t)
strcat(sql, ",?");
strcat(sql, ",?)");
CHKPrepare(T(sql), SQL_NTS, "S");
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &key, 0, &vind0, "S");
for (t = test_infos; t < test_infos+num_tests; ++t)
CHKBindParameter(t->num+1, SQL_PARAM_INPUT, t->c_type, t->sql_type, 0x10000000, 0, t->buf, 0, &t->vind, "S");
CHKBindParameter(num_tests+2, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &key, 0, &vind0, "S");
key = i;
vind0 = 0;
printf(">> insert... %d\n", i);
RetCode = CHKExecute("SINe");
while (RetCode == SQL_NEED_DATA) {
char *p;
RetCode = CHKParamData((SQLPOINTER) & p, "SINe");
printf(">> SQLParamData: ptr = %p RetCode = %d\n", (void *) p, RetCode);
if (RetCode == SQL_NEED_DATA) {
for (t = test_infos; t < test_infos+num_tests && t->buf != p; ++t)
;
assert(t < test_infos+num_tests);
if (t->c_type == SQL_C_CHAR || t->c_type == SQL_C_WCHAR) {
unsigned char_len = 1;
fill_hex(p, NBYTES, t->gen1, t->gen2);
if (t->c_type == SQL_C_WCHAR) {
char_len = sizeof(SQLWCHAR);
odbc_to_sqlwchar((SQLWCHAR*) p, p, NBYTES * 2);
}
CHKPutData(p, (NBYTES - (i&1)) * char_len, "S");
printf(">> param %p: total bytes written = %d\n", (void *) p, NBYTES - (i&1));
CHKPutData(p + (NBYTES - (i&1)) * char_len, (NBYTES + (i&1)) * char_len, "S");
printf(">> param %p: total bytes written = %d\n", (void *) p, NBYTES + (i&1));
} else {
CHKPutData(p, NBYTES, "S");
printf(">> param %p: total bytes written = %d\n", (void *) p, NBYTES);
}
}
}
CHKFreeHandle(SQL_HANDLE_STMT, (SQLHANDLE) odbc_stmt, "S");
odbc_stmt = SQL_NULL_HSTMT;
}
/* Now fetch rows ... */
for (wide = 0; wide < 2; ++wide)
for (i = 0; i < cnt; i++) {
/* MS do not save correctly char -> binary */
if (!odbc_driver_is_freetds() && i)
continue;
CHKAllocHandle(SQL_HANDLE_STMT, odbc_conn, &odbc_stmt, "S");
if (odbc_db_is_microsoft()) {
CHKSetStmtAttr(SQL_ATTR_CURSOR_SCROLLABLE, (SQLPOINTER) SQL_NONSCROLLABLE, SQL_IS_UINTEGER, "S");
CHKSetStmtAttr(SQL_ATTR_CURSOR_SENSITIVITY, (SQLPOINTER) SQL_SENSITIVE, SQL_IS_UINTEGER, "S");
}
strcpy(sql, "SELECT ");
for (t = test_infos; t < test_infos+num_tests; ++t)
sprintf(strchr(sql, 0), "f%u,", t->num);
strcat(sql, "v FROM #tt WHERE k = ?");
CHKPrepare(T(sql), SQL_NTS, "S");
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &i, 0, &vind0, "S");
for (t = test_infos; t < test_infos+num_tests; ++t) {
t->vind = SQL_DATA_AT_EXEC;
CHKBindCol(t->num, SQL_C_BINARY, NULL, 0, &t->vind, "S");
}
CHKBindCol(num_tests+1, SQL_C_LONG, &key, 0, &vind0, "S");
vind0 = 0;
CHKExecute("S");
CHKFetchScroll(SQL_FETCH_NEXT, 0, "S");
printf(">> fetch... %d\n", i);
for (t = test_infos; t < test_infos+num_tests; ++t) {
if (t->c_type == SQL_C_CHAR || t->c_type == SQL_C_WCHAR)
readBlobAsChar(t, i, wide);
else
readBlob(t);
}
CHKCloseCursor("S");
CHKFreeHandle(SQL_HANDLE_STMT, (SQLHANDLE) odbc_stmt, "S");
odbc_stmt = SQL_NULL_HSTMT;
}
odbc_stmt = old_odbc_stmt;
free_tests();
odbc_disconnect();
if (!failed)
printf("ok!\n");
return failed ? 1 : 0;
}
boost::uint32_t IteratorBase::myReadBlocks(PointBuffer& user_buffer)
{
boost::uint32_t numPointsRead = 0;
std::string const& query = getReader().getOptions().getValueOrThrow<std::string>("query");
::soci::row block;
::soci::indicator ind = ::soci::i_null;
::soci::statement blocks = (m_session->prepare << query, ::soci::into(block, ind));
blocks.execute();
bool bDidRead = blocks.fetch();
// if (ind == ::soci::i_null)
// {
// // We have no points to return
// getReader().log()->get(logDEBUG) << "Query returned no points" << std::endl;
// return 0;
// }
//
// size_t size = block.size();
// for (size_t i = 0; i < size; ++i)
// {
// getReader().log()->get(logDEBUG3) << "column: " << block.get_properties(i).get_name() << std::endl;
// }
if (!m_active_buffer)
{
m_active_buffer = fetchPointBuffer(block.get<int>("cloud_id"),
block.get<std::string>("schema"),
user_buffer.getCapacity());
m_active_cloud_id = block.get<int>("cloud_id");
}
//
// This shouldn't ever happen
int num_points = block.get<int>("num_points");
if (num_points > static_cast<boost::int32_t>(m_active_buffer->getCapacity()))
{
std::ostringstream oss;
oss << "Block size, " << num_points <<", is too large to fit in "
<< "buffer of size " << user_buffer.getCapacity() <<". Increase buffer capacity with writer's \"chunk_size\" option "
<< "or increase the read buffer size";
throw buffer_too_small(oss.str());
}
while (bDidRead)
{
boost::uint32_t numReadThisBlock = static_cast<boost::uint32_t>(block.get<int>("num_points"));
boost::uint32_t numSpaceLeftThisBuffer = user_buffer.getCapacity() - user_buffer.getNumPoints();
getReader().log()->get(logDEBUG4) << "IteratorBase::myReadBlocks:" "numReadThisBlock: "
<< numReadThisBlock << " numSpaceLeftThisBlock: "
<< numSpaceLeftThisBuffer << " total numPointsRead: "
<< numPointsRead << std::endl;
numPointsRead = numPointsRead + numReadThisBlock;
readBlob(block, (std::min)(numReadThisBlock, numSpaceLeftThisBuffer));
fillUserBuffer(user_buffer);
bDidRead = blocks.fetch();
// if (!bDidRead)
// return user_buffer.getNumPoints();
boost::int32_t const& current_cloud_id = block.get<int>("cloud_id");
if (current_cloud_id != m_active_cloud_id)
{
getReader().log()->get(logDEBUG3) << "IteratorBase::myReadBlocks: current_cloud_id: "
<< current_cloud_id << " m_active_cloud_id: "
<< m_active_cloud_id << std::endl;
m_active_buffer = fetchPointBuffer(current_cloud_id, block.get<std::string>("schema"), user_buffer.getCapacity());
m_active_cloud_id = current_cloud_id;
return user_buffer.getNumPoints();
}
}
return numPointsRead;
}
boost::uint32_t IteratorBase::myReadBlocks(PointBuffer& user_buffer)
{
boost::uint32_t numPointsRead = 0;
user_buffer.setNumPoints(0);
bool bDidRead = false;
if (!m_oracle_buffer)
{
m_oracle_buffer = fetchPointBuffer(m_initialQueryStatement, m_block->pc);
if (!m_oracle_buffer) throw pdal_error("m_oracle_buffer was NULL!");
m_dimension_map = fetchDimensionMap(m_initialQueryStatement, m_block->pc, *m_oracle_buffer, user_buffer);
boost::int32_t current_cloud_id(0);
current_cloud_id = m_initialQueryStatement->GetInteger(&m_block->pc->pc_id);
m_active_cloud_id = current_cloud_id;
}
// This shouldn't ever happen
if (m_block->num_points > static_cast<boost::int32_t>(m_oracle_buffer->getCapacity()))
{
m_oracle_buffer->resize(m_block->num_points);
}
if (!m_block->num_points)
{
// We still have a block of data from the last readBuffer call
// that was partially read.
getReader().log()->get(logDEBUG3) << "IteratorBase::myReadBlocks: fetching first block" << std::endl;
bDidRead = m_initialQueryStatement->Fetch();
if (!bDidRead)
{
m_at_end = true;
return 0;
}
user_buffer.setSpatialBounds(getBounds(m_initialQueryStatement, m_block));
}
else
{
// Our read was already "done" last readBuffer call, but if we're done,
// we're done
if (m_at_end)
getReader().log()->get(logDEBUG3) << "IteratorBase::myReadBlocks: we are at end of the blocks;" << std::endl;
else
getReader().log()->get(logDEBUG3) << "IteratorBase::myReadBlocks: we have points left to read on this block" << std::endl;
if (m_at_end) return 0;
bDidRead = true;
}
while (bDidRead)
{
boost::uint32_t numReadThisBlock = m_block->num_points;
boost::uint32_t numSpaceLeftThisBuffer = user_buffer.getCapacity() - user_buffer.getNumPoints();
getReader().log()->get(logDEBUG4) << "IteratorBase::myReadBlocks:" "numReadThisBlock: "
<< numReadThisBlock << " numSpaceLeftThisBlock: "
<< numSpaceLeftThisBuffer << " total numPointsRead: "
<< numPointsRead << std::endl;
numPointsRead = numPointsRead + numReadThisBlock;
readBlob(m_initialQueryStatement, m_block, m_block->num_points);
fillUserBuffer(user_buffer);
if (m_buffer_position != 0)
{
return user_buffer.getNumPoints();
}
else
{
bDidRead = m_initialQueryStatement->Fetch();
if (!bDidRead)
{
getReader().log()->get(logDEBUG3) << "IteratorBase::myReadBlocks: done reading block. Read " << numPointsRead << " points" << std::endl;
m_at_end = true;
return user_buffer.getNumPoints();
}
}
boost::int32_t current_cloud_id(0);
current_cloud_id = m_initialQueryStatement->GetInteger(&m_block->pc->pc_id);
getReader().log()->get(logDEBUG3) << "IteratorBase::myReadBlocks: current_cloud_id: "
<< current_cloud_id << " m_active_cloud_id: "
<< m_active_cloud_id << std::endl;
if (current_cloud_id != m_active_cloud_id)
{
m_oracle_buffer = fetchPointBuffer(m_initialQueryStatement, m_block->pc);
if (!m_oracle_buffer) throw pdal_error("m_oracle_buffer was NULL!");
m_dimension_map = fetchDimensionMap(m_initialQueryStatement, m_block->pc, *m_oracle_buffer, user_buffer);
m_active_cloud_id = current_cloud_id;
return user_buffer.getNumPoints();
}
}
return numPointsRead;
}
//! reads indices from database
void Table::loadIndices()
{
if (indicesLoadedM)
return;
indicesM.clear();
DatabasePtr db = getDatabase();
wxMBConv* conv = db->getCharsetConverter();
MetadataLoader* loader = db->getMetadataLoader();
// first start a transaction for metadata loading, then lock the table
// when objects go out of scope and are destroyed, table will be unlocked
// before the transaction is committed - any update() calls on observers
// can possibly use the same transaction
MetadataLoaderTransaction tr(loader);
SubjectLocker lock(this);
IBPP::Statement& st1 = loader->getStatement(
"SELECT i.rdb$index_name, i.rdb$unique_flag, i.rdb$index_inactive, "
" i.rdb$index_type, i.rdb$statistics, "
" s.rdb$field_name, rc.rdb$constraint_name, i.rdb$expression_source "
" from rdb$indices i "
" left join rdb$index_segments s on i.rdb$index_name = s.rdb$index_name "
" left join rdb$relation_constraints rc "
" on rc.rdb$index_name = i.rdb$index_name "
" where i.rdb$relation_name = ? "
" order by i.rdb$index_name, s.rdb$field_position "
);
st1->Set(1, wx2std(getName_(), conv));
st1->Execute();
Index* i = 0;
while (st1->Fetch())
{
std::string s;
st1->Get(1, s);
wxString ixname(std2wxIdentifier(s, conv));
short unq, inactive, type;
if (st1->IsNull(2)) // null = non-unique
unq = 0;
else
st1->Get(2, unq);
if (st1->IsNull(3)) // null = active
inactive = 0;
else
st1->Get(3, inactive);
if (st1->IsNull(4)) // null = ascending
type = 0;
else
st1->Get(4, type);
double statistics;
if (st1->IsNull(5)) // this can happen, see bug #1825725
statistics = -1;
else
st1->Get(5, statistics);
st1->Get(6, s);
wxString fname(std2wxIdentifier(s, conv));
wxString expression;
readBlob(st1, 8, expression, conv);
if (i && i->getName_() == ixname)
i->getSegments()->push_back(fname);
else
{
Index x(
unq == 1,
inactive == 0,
type == 0,
statistics,
!st1->IsNull(7),
expression
);
indicesM.push_back(x);
i = &indicesM.back();
i->setName_(ixname);
i->getSegments()->push_back(fname);
i->setParent(this);
}
}
indicesLoadedM = true;
}
void Domain::loadProperties(IBPP::Statement& statement, wxMBConv* converter)
{
setPropertiesLoaded(false);
statement->Get(2, &datatypeM);
if (statement->IsNull(3))
subtypeM = 0;
else
statement->Get(3, &subtypeM);
// determine the (var)char field length
// - system tables use field_len and char_len is null
// - computed columns have field_len/bytes_per_char, char_len is 0
// - view columns have field_len/bytes_per_char, char_len is null
// - regular table columns and SP params have field_len/bytes_per_char
// they also have proper char_len, but we don't use it now
statement->Get(4, &lengthM);
int bpc = 0; // bytes per char
if (!statement->IsNull(14))
statement->Get(14, &bpc);
if (bpc && (!statement->IsNull(8) || !statement->IsNull(13)))
lengthM /= bpc;
if (statement->IsNull(5))
precisionM = 0;
else
statement->Get(5, &precisionM);
if (statement->IsNull(6))
scaleM = 0;
else
statement->Get(6, &scaleM);
if (statement->IsNull(7))
charsetM = "";
else
{
std::string s;
statement->Get(7, s);
charsetM = std2wxIdentifier(s, converter);
}
bool notNull = false;
if (!statement->IsNull(9))
{
statement->Get(9, notNull);
}
nullableM = !notNull;
hasDefaultM = !statement->IsNull(10);
if (hasDefaultM)
{
readBlob(statement, 10, defaultM, converter);
defaultM = trimDefaultValue(defaultM);
}
else
defaultM = wxEmptyString;
if (statement->IsNull(11))
collationM = wxEmptyString;
else
{
std::string s;
statement->Get(11, s);
collationM = std2wxIdentifier(s, converter);
}
readBlob(statement, 12, checkM, converter);
setPropertiesLoaded(true);
}