bool TransCAD_Matrix::Write_Row (int org, int period)
{
if (!Data_Flag ()) return (false);
period = 0;
org = Org_Index (org);
if (org < 0) {
if (org < -1) return (false);
return (true);
}
for (int i=0; i < Tables (); i++) {
MATRIX_SetCore (fh, (short) i);
switch (Type ()) {
default:
case DB_DOUBLE:
MATRIX_SetBaseVector (fh, org, MATRIX_ROW, DOUBLE_TYPE, Row_Ptr (i));
break;
case DB_FLOAT:
MATRIX_SetBaseVector (fh, org, MATRIX_ROW, FLOAT_TYPE, Row_Ptr (i));
break;
case DB_INTEGER:
MATRIX_SetBaseVector (fh, org, MATRIX_ROW, LONG_TYPE, Row_Ptr (i));
break;
case DB_SHORT:
MATRIX_SetBaseVector (fh, org, MATRIX_ROW, SHORT_TYPE, Row_Ptr (i));
break;
}
if (tc_status != TC_OKAY) return (false);
}
return (true);
}
bool TPPlus_Matrix::Read_Header (bool stat)
{
int i;
char *header;
double size;
String label;
//---- extract the table names ----
stat = false;
Clear_Fields ();
header = (char *) fh->Mnames;
for (i=0; i < Tables (); i++) {
label = header;
if (label.empty ()) {
header++;
label ("%d") % (i + 1);
} else {
header += label.size () + 1;
}
size = sizeof (double);
if (fh->Mspecs [i] != 'D' && fh->Mspecs [i] != 'S') {
size += fh->Mspecs [i] / 10.0;
}
Add_Field (label, DB_DOUBLE, size, NO_UNITS, true);
}
Add_Field ("ORG", DB_INTEGER, 4, NO_UNITS, true);
Add_Field ("DES", DB_INTEGER, 4, NO_UNITS, true);
return (Set_Field_Numbers ());
}
bool TPPlus_Matrix::Read_Matrix (void)
{
int n;
Int_Map *org_map;
Int_Map_Itr org_itr;
if (!Data_Flag () || !Matrix_Flag ()) {
if (!Allocate_Data (true)) return (false);
}
exe->Show_Message (String ("Reading %s -- Record") % File_Type ());
exe->Set_Progress ();
org_map = Org_Map ();
for (org_itr = org_map->begin (); org_itr != org_map->end (); org_itr++) {
for (n=0; n < Tables (); n++) {
exe->Show_Progress ();
TppMatReadSelect (fh, org_itr->first, n+1, Matrix_Ptr (0, org_itr->second, n));
}
}
exe->End_Progress ();
exe->Print (2, String ("Number of %s Records = %d") % File_Type () % exe->Progress_Count ());
return (true);
}
bool TPPlus_Matrix::Write_Matrix (void)
{
int i, n, org;
Int_Map *org_map;
Int_Map_Itr org_itr;
if (!Matrix_Flag ()) return (false);
exe->Show_Message (String ("Writing %s -- Record") % File_Type ());
exe->Set_Progress ();
org_map = Org_Map ();
//---- process each origin zone ----
for (org_itr = org_map->begin (); org_itr != org_map->end (); org_itr++) {
org = org_itr->first - 1;
i = org_itr->second;
for (n=0; n < Tables (); n++) {
exe->Show_Progress ();
TppMatMatWriteRow (fh, org, n+1, fh->Mspecs [n], Matrix_Ptr (0, i, n));
}
}
exe->End_Progress ();
exe->Print (2, String ("Number of %s Records = %d") % File_Type () % exe->Progress_Count ());
return (true);
}
/**
* Create new thread that will handle with all
* Simulators for all sensors
*/
int StartSensorSimulation(void)
{
Trie*const db=Tables();
pthread_t simulationthread;
if(pthread_create(&simulationthread, NULL, &Simulator, db)) return EXIT_FAILURE;
else return EXIT_SUCCESS;
}
// ////////////////////////////////////////////////////////////////////////////
ResultInfoTablesSet &OdbcHandleStmt::GetResultInfoTables(
ResultInfoTablesSet &out_list, const char *CatalogName,
const char *SchemaName, const char *TableName, const char *TableType,
OdbcThrowFlags::Flags throw_flags) const
{
ResultInfoTablesSet tmp_list;
try {
Tables(CatalogName, SchemaName, TableName, TableType, throw_flags);
SQLSMALLINT col_count;
NumResultCols(&col_count);
SQLRETURN row_return_code;
ResultInfoTablesRaw raw_data;
raw_data.Bind(*this, col_count);
while (SQL_SUCCEEDED(row_return_code = Fetch())) {
tmp_list.insert(raw_data);
raw_data.Clear();
}
}
catch (const std::exception &except) {
MLB::Utility::Rethrow(except, "Unable to load table information: " +
std::string(except.what()));
}
out_list.swap(tmp_list);
return(out_list);
}
bool TPPlus_Matrix::Write_Row (int org, int period)
{
if (!Data_Flag ()) return (false);
period = 0;
for (int i=0; i < Tables (); i++) {
if (TppMatMatWriteRow (fh, org, i+1, fh->Mspecs [i], Row_Ptr (i)) != 1) return (false);
}
return (true);
}
bool TPPlus_Matrix::Read_Row (int org, int period)
{
if (!Data_Flag ()) {
if (!Allocate_Data ()) return (false);
}
period = 0;
for (int i=0; i < Tables (); i++) {
if (TppMatReadSelect (fh, org, i+1, Row_Ptr (i)) != 1) return (false);
}
return (true);
}
bool TransCAD_Matrix::Write_Matrix (void)
{
int i, n, org;
DATA_TYPE type;
Int_Map *org_map;
Int_Map_Itr org_itr;
if (!Matrix_Flag ()) return (false);
exe->Show_Message (String ("Writing %s -- Record") % File_Type ());
exe->Set_Progress ();
org_map = Org_Map ();
switch (Type ()) {
default:
case DB_DOUBLE:
type = DOUBLE_TYPE;
break;
case DB_FLOAT:
type = FLOAT_TYPE;
break;
case DB_INTEGER:
type = LONG_TYPE;
break;
case DB_SHORT:
type = SHORT_TYPE;
break;
}
//---- process each origin zone ----
for (org_itr = org_map->begin (); org_itr != org_map->end (); org_itr++) {
org = org_itr->first - 1;
i = org_itr->second;
for (n=0; n < Tables (); n++) {
exe->Show_Progress ();
MATRIX_SetCore (fh, (short) n);
MATRIX_SetBaseVector (fh, org, MATRIX_ROW, type, Matrix_Ptr (0, i, n));
}
}
exe->End_Progress ();
exe->Print (2, String ("Number of %s Records = %d") % File_Type () % exe->Progress_Count ());
return (true);
}
NamesAndTypesList getStructureOfRemoteTable(
const Cluster & cluster,
const std::string & database,
const std::string & table,
const Context & context)
{
/// Запрос на описание таблицы
String query = "DESC TABLE " + backQuoteIfNeed(database) + "." + backQuoteIfNeed(table);
Settings settings = context.getSettings();
NamesAndTypesList res;
/// Отправляем на первый попавшийся удалённый шард.
const auto & shard_info = cluster.getAnyShardInfo();
if (shard_info.isLocal())
return context.getTable(database, table)->getColumnsList();
ConnectionPoolPtr pool = shard_info.pool;
BlockInputStreamPtr input =
std::make_shared<RemoteBlockInputStream>(
pool.get(), query, &settings, nullptr,
Tables(), QueryProcessingStage::Complete, context);
input->readPrefix();
const DataTypeFactory & data_type_factory = DataTypeFactory::instance();
while (Block current = input->read())
{
ColumnPtr name = current.getByName("name").column;
ColumnPtr type = current.getByName("type").column;
size_t size = name->size();
for (size_t i = 0; i < size; ++i)
{
String column_name = (*name)[i].get<const String &>();
String data_type_name = (*type)[i].get<const String &>();
res.emplace_back(column_name, data_type_factory.get(data_type_name));
}
}
return res;
}
void execute(ConnectionPool::Entry & connection, Query & query)
{
Stopwatch watch;
RemoteBlockInputStream stream(*connection, query, &settings, nullptr, Tables(), query_processing_stage);
Progress progress;
stream.setProgressCallback([&progress](const Progress & value) { progress.incrementPiecewiseAtomically(value); });
stream.readPrefix();
while (Block block = stream.read())
;
stream.readSuffix();
const BlockStreamProfileInfo & info = stream.getProfileInfo();
double seconds = watch.elapsedSeconds();
std::lock_guard<std::mutex> lock(mutex);
info_per_interval.add(seconds, progress.rows, progress.bytes, info.rows, info.bytes);
info_total.add(seconds, progress.rows, progress.bytes, info.rows, info.bytes);
}
bool TransCAD_Matrix::Read_Header (bool stat)
{
int i;
char label [_MAX_FLABEL];
double size;
Field_Type type;
String text;
//---- extract the table names ----
Clear_Fields ();
stat = false;
type = Type ();
if (type == DB_DOUBLE) {
size = sizeof (double);
} else if (type == DB_FLOAT) {
type = DB_DOUBLE;
size = sizeof (float);
} else if (type == DB_SHORT) {
type = DB_INTEGER;
size = sizeof (short);
} else {
size = sizeof (int);
}
for (i=0; i < Tables (); i++) {
MATRIX_GetLabel (fh, (short) i, label);
text = label;
Add_Field (text, type, size, NO_UNITS, true);
}
Add_Field ("ORG", DB_INTEGER, 4, NO_UNITS, true);
Add_Field ("DES", DB_INTEGER, 4, NO_UNITS, true);
return (Set_Field_Numbers ());
}
bool TransCAD_Matrix::Db_Open (string filename)
{
int i;
DATA_TYPE data_type;
if (!Load_DLL ()) return (Status (NO_TRANSCAD));
Set_Field_Numbers ();
if (File_Access () == CREATE) {
int len;
char **core_names;
Db_Field *fld_ptr;
if (Num_Des () == 0 || Tables () == 0) return (false);
if (Type () == DB_DOUBLE) {
data_type = DOUBLE_TYPE;
} else if (Type () == DB_FLOAT) {
data_type = FLOAT_TYPE;
} else if (Type () == DB_SHORT) {
data_type = SHORT_TYPE;
} else {
data_type = LONG_TYPE;
}
core_names = new char * [Tables ()];
for (i=0; i < Tables (); i++) {
fld_ptr = Table_Field (i);
len = (int) fld_ptr->Name ().length () + 1;
core_names [i] = new char [len];
strcpy_s (core_names [i], len, fld_ptr->Name ().c_str ());
}
if ((int) Org_Map ()->size () != Num_Org () || (int) Des_Map ()->size () != Num_Des ()) {
for (i=1; i <= Num_Org (); i++) {
Add_Org (i);
}
for (i=1; i <= Num_Des (); i++) {
Add_Des (i);
}
fh = MATRIX_New ((char *) filename.c_str (), (char *) File_Type ().c_str (),
Num_Org (), 0, Num_Des (), 0, Tables (), core_names, data_type, 1);
} else {
int i;
Integers row_ids, col_ids;
Int_Map_Itr map_itr;
row_ids.assign (Num_Org (), 0);
for (i=0, map_itr = Org_Map ()->begin (); map_itr != Org_Map ()->end (); map_itr++, i++) {
row_ids [i] = map_itr->first;
}
col_ids.assign (Num_Des (), 0);
for (i=0, map_itr = Des_Map ()->begin (); map_itr != Des_Map ()->end (); map_itr++, i++) {
col_ids [i] = map_itr->first;
}
fh = MATRIX_New ((char *) filename.c_str (), (char *) File_Type ().c_str (),
Num_Org (), (long *) &row_ids [0], Num_Des (), (long *) &col_ids [0],
Tables (), core_names, data_type, 1);
}
for (i=0; i < Tables (); i++) {
delete [] core_names [i];
}
delete [] core_names;
} else {
fh = MATRIX_LoadFromFile ((char *) filename.c_str (), CONTROL_AUTOMATIC);
if (tc_status != TC_OKAY || fh == 0) return (false);
Num_Org (MATRIX_GetNRows (fh));
Num_Des (MATRIX_GetNCols (fh));
data_type = MATRIX_GetDataType (fh);
if (data_type == DOUBLE_TYPE) {
Type (DB_DOUBLE);
} else if (data_type == FLOAT_TYPE) {
Type (DB_FLOAT);
} else if (data_type == SHORT_TYPE) {
Type (DB_SHORT);
} else {
Type (DB_INTEGER);
}
Tables (MATRIX_GetNCores (fh));
Integers ids;
ids.assign (Num_Org (), 0);
MATRIX_GetIDs(fh, MATRIX_ROW, (long *) &(ids [0]));
for (i=0; i < Num_Org (); i++) {
Add_Org (ids [i]);
}
ids.assign (Num_Des (), 0);
MATRIX_GetIDs(fh, MATRIX_COL, (long *) &(ids [0]));
for (i=0; i < Num_Des (); i++) {
Add_Des (ids [i]);
}
}
return (true);
}
bool TPPlus_Matrix::Db_Open (string filename)
{
int i, type;
char *license = 0;
if (!Load_DLL ()) return (Status (NO_TPPLUS));
Set_Field_Numbers ();
if (File_Access () == CREATE) {
int len;
unsigned char *header;
Db_Field *fld_ptr;
if (Num_Des () == 0 || Tables () == 0) return (false);
if (Dbase_Format () == TRANPLAN) {
type = TPLAN;
} else {
type = TPP;
}
TppMatMatSet (&fh, type, (char *) filename.c_str (), Num_Des (), Tables ());
header = fh->Mnames;
for (i=0; i < Tables (); i++) {
fld_ptr = Table_Field (i);
if (fld_ptr->Decimal () == 0) {
fh->Mspecs [i] = 'D';
} else {
fh->Mspecs [i] = (unsigned char) fld_ptr->Decimal ();
}
len = (int) fld_ptr->Name ().length () + 1;
memcpy (header, fld_ptr->Name ().c_str (), len);
header += len;
}
if ((i = TppMatOpenOP (fh, (char *) File_ID ().c_str (), (char *) exe->Program (), 0, license, CUBE)) <= 0) {
if (i < -1) {
return (Status (TPPLUS_LICENSE));
} else {
return (false);
}
}
TppMatMatResize (&fh);
} else {
if (FileInquire ((char *) filename.c_str (), &fh) <= 0) return (false);
if ((i = TppMatOpenIP (fh, license, CUBE)) <= 0) {
if (i < -1) {
return (Status (TPPLUS_LICENSE));
} else {
return (false);
}
}
Num_Org (fh->zones);
Num_Des (fh->zones);
Tables (fh->mats);
}
for (i=1; i <= Num_Des (); i++) {
Add_Org (i);
Add_Des (i);
}
fh->buffer = (void *) new char [fh->bufReq];
return (true);
}
