bool JsonDbBtree::putOne(const QByteArray &key, const QByteArray &value)
{
bool inTransaction = mBtree->isWriting();
Transaction *txn = inTransaction ? mBtree->writeTransaction() : mBtree->beginWrite();
bool ok = txn->put(key, value);
if (!inTransaction) {
qWarning() << "JsonDbBtree::putOne" << "auto commiting tag 0";
ok &= txn->commit(0);
}
return ok;
}
// IToolLoop interface
void dispose() override
{
bool redraw = false;
if (!m_canceled) {
// Paint ink
if (getInk()->isPaint()) {
try {
ContextReader reader(m_context, 500);
ContextWriter writer(reader, 500);
m_expandCelCanvas.commit();
}
catch (const LockedDocumentException& ex) {
Console::showException(ex);
}
}
// Selection ink
else if (getInk()->isSelection()) {
m_document->generateMaskBoundaries();
redraw = true;
// Show selection edges
m_docPref.show.selectionEdges(true);
}
m_transaction.commit();
}
else
redraw = true;
// If the trace was canceled or it is not a 'paint' ink...
if (m_canceled || !getInk()->isPaint()) {
try {
ContextReader reader(m_context, 500);
ContextWriter writer(reader, 500);
m_expandCelCanvas.rollback();
}
catch (const LockedDocumentException& ex) {
Console::showException(ex);
}
}
if (redraw)
update_screen_for_document(m_document);
}
void PackageGroup::SaveToDatabase(Transaction *transaction)
{
Database *database = Database::getInstance();
Transaction *ts = transaction;
auto_ptr<Transaction> local_ts;
if (!transaction) {
local_ts = auto_ptr<Transaction>(database->getTransaction("SavePackageGroup"));
ts = local_ts.get();
}
if (!mTapeSourcePackage->isPersistent())
database->savePackage(mTapeSourcePackage, ts);
size_t i;
for (i = 0; i < mFileSourcePackages.size(); i++)
database->savePackage(mFileSourcePackages[i], ts);
database->savePackage(mMaterialPackage, ts);
if (!transaction)
ts->commit();
}
//this command lets you select an a block reference (no xrefs supported yet, but I hope to add
//that by FCS) and then an (first level) object within the block reference.
//Then you can decide if you want to move the object to the top or to the bottom in the
//draworder.
//Note that this command uses the AcDbFilter and AcDbIndex classes. This mechanism is
//NOT the same that DRAWORDER command uses in model space and layout.
void blockOrder()
{
resbuf* res = NULL;
try
{
Transaction trans;
int rt;
ads_name ename;
ads_point pt;
if ((rt=acedEntSel("Select a reference:",ename,pt))==RTCAN)
return;
if (rt!=RTNORM)
throw Acad::eInvalidInput;
Ptr<AcDbBlockReference> pBlkRef(ename,AcDb::kForWrite);
//get block table record
Ptr<AcDbBlockTableRecord> pBTR(pBlkRef->blockTableRecord(),AcDb::kForWrite);
Acad::ErrorStatus es;
//get or add index
Ptr<AsdkBlockOrderIndex> pIndex;
es = AcDbIndexFilterManager::getIndex(pBTR,AsdkBlockOrderIndex::desc(),AcDb::kForWrite,(AcDbIndex*&)pIndex);
if (es==Acad::eKeyNotFound)
{
if ((pIndex=AsdkBlockOrderIndex::cast(
AsdkBlockOrderIndex::desc()->create()))==NULL)
throw Acad::eOutOfMemory;
ARXOK(AcDbIndexFilterManager::addIndex(pBTR, pIndex));
} else if (es!=Acad::eOk)
throw es;
//get or add filter
Ptr<AsdkBlockOrderFilter> pFilter;
es = AcDbIndexFilterManager::getFilter(pBlkRef,AsdkBlockOrderFilter::desc(),AcDb::kForWrite,(AcDbFilter*&)pFilter);
if (es==Acad::eKeyNotFound)
{
if ((pFilter=AsdkBlockOrderFilter::cast(
AsdkBlockOrderFilter::desc()->create()))==NULL)
throw Acad::eOutOfMemory;
ARXOK(AcDbIndexFilterManager::addFilter(pBlkRef,pFilter));
} else if (es!=Acad::eOk)
throw es;
//prompt for object to be moved
ads_point xform[4];
resbuf *temp,*last,*lastButOne;
ads_name eobj;
do
{
if (res!=NULL)
acutRelRb(res);
res = NULL;temp = NULL;last = NULL; lastButOne=NULL;
if ((rt=acedNEntSel("\nSelect entity to order:",eobj,pt,xform,&res))==RTCAN)
return;
if (rt!=RTNORM)
throw Acad::eInvalidInput;
temp=res;
last=temp;
while (temp!=NULL && temp->rbnext!=NULL){
lastButOne=temp;
temp=temp->rbnext;
last = temp;
}
}
//prompt until we find an object within the original block reference
while (res==NULL || last==NULL || (last!=NULL && last->resval.rlname[0]!=ename[0]));
AcDbObjectId idObj;
//if the object selected is within a block reference (nested block)
//then just add the block reference (NOTE that eobj is the inner most object
//and we only sort objects within the this reference.)
if (lastButOne!=NULL)
ARXOK(acdbGetObjectId(idObj,lastButOne->resval.rlname));
else
ARXOK(acdbGetObjectId(idObj,eobj));
acutRelRb(res);
//find out where to move the object
if (acedInitGet(0,"TOP,T BOTTOM,B")!=RTNORM)
throw Acad::eInvalidInput;
char result[512];
if ((rt=acedGetKword("\nMove to [Top/Bottom]:",result))==RTCAN)
return;
if (rt!=RTNORM)
throw Acad::eInvalidInput;
if (stricmp(result,"TOP")==0)
pFilter->moveToTop(idObj);
else if (stricmp(result,"BOTTOM")==0)
pFilter->moveToBottom(idObj);
pIndex->setLastUpdatedAtU(pBTR->database()->tduupdate());
//make sure that the reference is redrawn
pBlkRef->assertWriteEnabled();
trans.commit();
}
catch (Acad::ErrorStatus es)
{
if (res!=NULL)
acutRelRb(res);
acutPrintf("\nError: es==%s",acadErrorStatusText(es));
}
}
int main(int argc, char* argv[])
{
bool debug = false;
char *inStr = argv[1];
long pkg_identifier;
long packages[100000];
// Delete packages from database
try
{
// Initialise
prodauto::Database::initialise("localhost", "prodautodb", "bamzooki", "bamzooki", 4, 12);
Database* db = Database::getInstance();
Transaction* transaction = (db->getTransaction("DeletePackages"));
// String to array
char *nextTok = strtok(inStr, ",");
int i=0;
while(nextTok != NULL){
packages[i] = atol(nextTok);
i++;
nextTok = strtok(NULL, ",");
}
int noPackages = i;
if(noPackages == 0){
printf("Error! No package IDs supplied.\n");
return 1;
}
for (i = 0; i < noPackages; i++){
try
{
pkg_identifier = packages[i];
if(debug){printf("Loading package: %li\n", pkg_identifier);}
Package* package = (db->loadPackage(pkg_identifier));
db->deletePackageChain(package, transaction);
transaction->commit();
if(debug){printf("Deleted package\n");}
}
catch (const prodauto::DBException & dbe)
{
printf("Error deleting packages\n");
return 1;
}
}
printf("Deleted %i material item(s)\n", noPackages);
return 0;
//TODO: Check for unreferenced isolated packages
}
catch (const prodauto::DBException & dbe)
{
printf("Error\n");
return 1;
}
}
Q4Out Transactions::q4Transaction(Transaction& tx, Context &context, const Q4In& in)
{
Q4Out result;
try {
auto schema = tx.getSchema(context.wideTable);
// idea: we have to group by cityName
// 5 different unique values
// aggregate them all in separate scans
uint32_t selectionLength = 72;
std::unique_ptr<char[]> selection(new char[selectionLength]);
crossbow::buffer_writer selectionWriter(selection.get(), selectionLength);
selectionWriter.write<uint32_t>(0x3u);
selectionWriter.write<uint16_t>(0x3u);
selectionWriter.write<uint16_t>(0x0u);
selectionWriter.write<uint32_t>(0x0u);
selectionWriter.write<uint32_t>(0x0u);
selectionWriter.write<uint16_t>(context.regionCity);
selectionWriter.write<uint16_t>(0x1u);
selectionWriter.set(0, 4);
selectionWriter.write<uint8_t>(crossbow::to_underlying(PredicateType::EQUAL));
selectionWriter.write<uint8_t>(0x0u);
selectionWriter.set(0, 2);
const auto varyPtr = reinterpret_cast<int32_t*>(selectionWriter.data());
selectionWriter.write<int32_t>(0); // we are going to vary this
selectionWriter.write<uint16_t>(context.callsSumLocalWeek);
selectionWriter.write<uint16_t>(0x1u);
selectionWriter.set(0, 4);
selectionWriter.write<uint8_t>(crossbow::to_underlying(PredicateType::GREATER));
selectionWriter.write<uint8_t>(0x1u);
selectionWriter.set(0, 2);
selectionWriter.write<int32_t>(in.alpha);
selectionWriter.write<uint16_t>(context.durSumLocalWeek);
selectionWriter.write<uint16_t>(0x1u);
selectionWriter.set(0, 4);
selectionWriter.write<uint8_t>(crossbow::to_underlying(PredicateType::GREATER));
selectionWriter.write<uint8_t>(0x2u);
selectionWriter.set(0, 6);
selectionWriter.write<int64_t>(in.beta);
// sort aggregation attributes
std::array<std::tuple<id_t, AggregationType, FieldType, crossbow::string>, 3> aggregationAttributes = {{
std::make_tuple(context.callsSumLocalWeek, AggregationType::SUM, FieldType::BIGINT,
"sum_calls_sum_local_week"),
std::make_tuple(context.callsSumLocalWeek, AggregationType::CNT, FieldType::BIGINT,
"cnt_calls_sum_local_week"),
std::make_tuple(context.durSumLocalWeek, AggregationType::SUM, FieldType::BIGINT,
"dur_sum_local_week")
}};
Schema resultSchema(schema.type());
uint32_t aggregationLength = 4 * aggregationAttributes.size();
std::unique_ptr<char[]> aggregation(new char[aggregationLength]);
crossbow::buffer_writer aggregationWriter(aggregation.get(), aggregationLength);
for (auto &attribute : aggregationAttributes) {
aggregationWriter.write<uint16_t>(std::get<0>(attribute));
aggregationWriter.write<uint16_t>(crossbow::to_underlying(std::get<1>(attribute)));
resultSchema.addField(std::get<2>(attribute), std::get<3>(attribute), true);
}
Table resultTable(context.wideTable.value, std::move(resultSchema));
auto &snapshot = tx.snapshot();
auto &clientHandle = tx.getHandle();
std::vector<std::shared_ptr<ScanIterator>> scanIterators;
uint16_t numberOfCities = region_unique_city.size();
scanIterators.reserve(numberOfCities);
for (int16_t i = 0; i < numberOfCities; ++i)
{
*varyPtr = i;
scanIterators.push_back(clientHandle.scan(resultTable, snapshot,
*context.scanMemoryMananger, ScanQueryType::AGGREGATION, selectionLength,
selection.get(), aggregationLength, aggregation.get()));
}
// process results from aggregations
for (int16_t i = 0; i < numberOfCities; ++i)
{
auto &scanIterator = scanIterators[i];
if (scanIterator->hasNext()) {
const char* tuple;
size_t tupleLength;
std::tie(std::ignore, tuple, tupleLength) = scanIterator->next();
auto sumCallsSumLocalWeek = resultTable.field<int64_t>(
"sum_calls_sum_local_week", tuple);
auto cntCallsSumLocalWeek = resultTable.field<int64_t>(
"cnt_calls_sum_local_week", tuple);
auto durSumLocalWeek = resultTable.field<int64_t>(
"dur_sum_local_week", tuple);
if (cntCallsSumLocalWeek > 0) {
Q4Out::Q4Tuple q4Tuple;
q4Tuple.city_name = region_unique_city[i];
q4Tuple.avg_num_local_calls_week =
static_cast<double>(sumCallsSumLocalWeek)
/ cntCallsSumLocalWeek;
q4Tuple.sum_duration_local_calls_week = durSumLocalWeek;
result.results.push_back(std::move(q4Tuple));
}
}
}
result.success = true;
tx.commit();
for (auto &scanIterator: scanIterators) {
if (scanIterator->error()) {
result.error = crossbow::to_string(scanIterator->error().value());
result.success = false;
return result;
}
}
} catch (std::exception& ex) {
result.success = false;
result.error = ex.what();
}
return result;
}
