Optimizing my database simulator code (2)

A few days ago I asked you a question and I have some really useful answers. I will make a summary for those of you who have not read, and I will explain my new doubts and where I have problems.

Explanation

I am working on a program that simulates a small database, which primarily reads information from txt files and stores them in computer memory, and then I can make queries using regular tables and / or transposed tables. The problem is that performance is still not enough. It runs slower than I expect. I improved it, but I think I should improve it more. I have specific moments when my program does not have good performance.

Current problem

The first problem that I have now (where my program is slower) is that I spend more time, for example, on a table with 100,000 columns and 100 rows (0.325 min, I improved it thanks to your help) than 100 000 rows and 100 columns (1.61198 min, same as before). But, on the other hand, the access time to some data is better in the second case (in a specific example, 47 seconds versus 6079 seconds in the first case) any idea why ??

Explanation

Now let me remind you how my code works (with a saved summary of my code)

First of all, I have a .txt file that mimics a database table with random strings separated by "|". Here is an example table (with 7 rows and 5 columns). I also have a transposed table

NormalTable.txt

42sKuG^uM|24465\lHXP|2996fQo\kN|293cvByiV|14772cjZ`SN|
28704HxDYjzC|6869xXj\nIe|27530EymcTU|9041ByZM]I|24371fZKbNk|
24085cLKeIW|16945TuuU\Nc|16542M[Uz\|13978qMdbyF|6271ait^h|
13291_rBZS|4032aFqa|13967r^\\`T|27754k]dOTdh|24947]v_uzg|
1656nn_FQf|4042OAegZq|24022nIGz|4735Syi]\|18128klBfynQ|
6618t\SjC|20601S\EEp|11009FqZN|20486rYVPR|7449SqGC|
14799yNvcl|23623MTetGw|6192n]YU\Qe|20329QzNZO_|23845byiP|

TransposedTable.txt ( )

42sKuG^uM|28704HxDYjzC|24085cLKeIW|13291_rBZS|1656nn_FQf|6618t\SjC|14799yNvcl|
24465\lHXP|6869xXj\nIe|16945TuuU\Nc|4032aFqa|4042OAegZq|20601S\EEp|23623MTetGw|
2996fQo\kN|27530EymcTU|16542M[Uz\|13967r^\\`T|24022nIGz|11009FqZN|6192n]YU\Qe|
293cvByiV|9041ByZM]I|13978qMdbyF|27754k]dOTdh|4735Syi]\|20486rYVPR|20329QzNZO_|
14772cjZ`SN|24371fZKbNk|6271ait^h|24947]v_uzg|18128klBfynQ|7449SqGC|23845byiP|

TXT . , . , , .

, .

, Table.txt

int h;
do
{
    cout<< "Do you want to query the normal table or the transposed table? (1- Normal table/ 2- Transposed table):" ;
    cin>>h; 
}while(h!=1 && h!=2);

string ruta_base("C:\\Users\\Raul Velez\\Desktop\\Tables\\");
if(h==1)
{
    ruta_base +="NormalTable.txt"; // Folder where my "Table.txt" is found
}

if(h==2)
{
    ruta_base +="TransposedTable.txt";
}

string temp; // Variable where every row from the Table.txt file will be firstly stored
vector<string> buffer; // Variable where every different row will be stored after separating the different elements by tokens.
vector<ElementSet> RowsCols; // Variable with a class that I have created, that simulated a vector and every vector element is a row of my table

ifstream ifs(ruta_base.c_str());
while(getline( ifs, temp )) // We will read and store line per line until the end of the ".txt" file. 
{
    size_t tokenPosition = temp.find("|"); // When we find the simbol "|" we will identify different element. So we separate the string temp into tokens that will be stored in vector<string> buffer
    // --- NEW PART ------------------------------------
    const char* p = temp.c_str();
    char* p1 = strdup(p);

    char* pch = strtok(p1, "|");
    while(pch)
    {
            buffer.push_back(string(pch));
            pch = strtok(NULL,"|");
    }
    free(p1);

    ElementSet sss(0,buffer);
    buffer.clear();
    RowsCols.push_back(sss); // We store all the elements of every row (stores as vector<string> buffer) in a different position in "RowsCols" 
    // --- NEW PART END ------------------------------------
}

Table TablesStorage(RowsCols); // After every loop we will store the information about every .txt file in the vector<Table> TablesDescriptor
vector<Table> TablesDescriptor;
TablesDescriptor.push_back(TablesStorage); // In the vector<Table> TablesDescriptor will be stores all the different tables with all its information

DataBase database(1, TablesDescriptor);

,

. , , . , - "n", "numTuples" "y". ( , "y", , , , 54 (00110110 ) 2, 3, 5 6). , Vector. .

if (h == 2), , : ?

,

int n, numTuples; 
unsigned long long int y;

cout<< "Write the ID of the row you want to get more information: " ;
cin>>n; // We get the row to be represented -> "n"

cout<< "Write the number of followed tuples to be queried: " ;
cin>>numTuples; // We get the number of followed tuples to be queried-> "numTuples"

cout<<"Write the ID of the 'columns' you want to get more information: ";
cin>>y; // We get the "columns" to be represented ' "y"

unsigned int r; // Auxiliar variable for the columns path
int t=0; // Auxiliar variable for the tuples path
int idTable;

vector<int> columnsToBeQueried; // Here we will store the columns to be queried get from the bitset<500> binarynumber, after comparing with a mask
vector<string> shownVector; // Vector to store the final information from the query
bitset<5000> mask;
mask=0x1;

clock_t t1, t2;
t1=clock(); // Start of the query time

bitset<5000> binaryNumber = Utilities().getDecToBin(y); // We get the columns -> change number from decimal to binary. Max number of columns: 5000

// We see which columns will be queried
for(r=0;r<binaryNumber.size();r++) //
{               
    if(binaryNumber.test(r) & mask.test(r))  // if both of them are bit "1"
    {
        columnsToBeQueried.push_back(r);
    }
    mask=mask<<1;   
}

do
{
    for(int z=0;z<columnsToBeQueried.size();z++)
    {
        ElementSet selectedElementSet;
        int i;
        i=columnsToBeQueried.at(z);
        Table& selectedTable = database.getPointer().at(0); // It simmulates a vector with pointers to different tables that compose the database, but our example database only have one table, so don't worry ElementSet selectedElementSet;
        if(h == 1)
        {

            selectedElementSet=selectedTable.getRowsCols().at(n);
            shownVector.push_back(selectedElementSet.getElements().at(i)); // We save in the vector shownVector the element "i" of the row "n"
        }

        if(h == 2)  
        {
            selectedElementSet=selectedTable.getRowsCols().at(i);
            shownVector.push_back(selectedElementSet.getElements().at(n)); // We save in the vector shownVector the element "n" of the row "i"
        }
        n=n+1;
        t++;            
    }
}while(t<numTuples);

t2=clock(); // End of the query time
showVector().finalVector(shownVector);
float diff ((float)t2-(float)t1);
float microseconds = diff / CLOCKS_PER_SEC*1000000;
cout<<"Time: "<<microseconds<<endl;

, , :

class ElementSet
{
private:
    int id;
    vector<string> elements; 

public:
    ElementSet(); 
    ElementSet(int, vector<string>&); 

    const int& getId();
    void setId(int);

    const vector<string>& getElements();
    void setElements(vector<string>);

};

class Table
{
private:
    vector<ElementSet> RowsCols; 

public:
    Table(); 
    Table(vector<ElementSet>&); 

    const vector<ElementSet>& getRowsCols();
    void setRowsCols(vector<ElementSet>);
};


class DataBase
{
     private:
        int id;
        vector<Table> pointer; 

     public:
        DataBase(); 
        DataBase(int, vector<Table>&); 

    const int& getId();
    void setId(int);

    const vector<Table>& getPointer();
    void setPointer(vector<Table>);

    };

class Utilities
{
        public:
        Utilities();
        static bitset<500> getDecToBin(unsigned long long int);
};

• .
• ( - , ?)

!!!:)