hashjoin

#include <iostream>
#include "HashTable.h"


HashTable::HashTable(int serverCount, int playerCount,int numberOfServersInArray)
{
    this->numberOfBuckets = 0;
    this->numberOfErrors= 0;
    this->serverCount = serverCount;
    this->playerCount = playerCount;
    this->numberOfServersInArray=numberOfServersInArray;

    numberOfBuckets = this->serverCount/this->numberOfServersInArray;//pocet prihradek serveru
    numberOfBuckets+=1;

    srvArray = new int*[numberOfBuckets];

    for(int i = 0; i<numberOfBuckets;i++)
    {
        srvArray[i]= new int[numberOfServersInArray]; //pole serveru ktere ma X (pocet prihradek) radku a srvCount/x sloupcu
    }

    indexArray = new int*[numberOfBuckets];// pomocne pole, druhy rozmer aktualni mozna velikost radku totozneho s indexem radku v srvArray,
    //aby se vedelo, kdy se ma udelat resize
    //prvni rozmer, aktualni pocet serveru v prihradce

    for(int i = 0;i<numberOfBuckets;i++)
    {
        indexArray[i]=new int[2];
    }

    serverIDs = new int[serverCount]; //pole vsech ID serveru
    playerIDs = new int[playerCount]; //pole vsech ID playeru
    playerSRV = new int[playerCount]; //pole IDserveru vsech playeru
}

HashTable::~HashTable()
{
    for(int i = 0;i<this->numberOfBuckets;i++)
    {
        delete []srvArray[i];
    }
    delete []srvArray;

    for(int i = 0;i<this->numberOfBuckets;i++)
    {
        delete []indexArray[i];
    }
    delete []indexArray;


    delete[]serverIDs;
    delete[]playerIDs;
    delete[]playerSRV;
}

int HashTable::getErrors()
{
    return this->numberOfErrors;
}

void HashTable::setErrors(int errors)
{
    this->numberOfErrors = errors;
}

void HashTable::checkIfCorrect(int serverID, int playerID)
{
    for(int i = 0; i < playerCount;i++)
    {
        if(playerIDs[i]==playerID)
        {
            if(serverID!=playerSRV[i])
            {
                std::cout << i << std::endl;
            }
        }
    }
}

void HashTable::prepareDateForNonPartition(Server **servers, Player **players)
{
    for(int i = 0;i<serverCount;i++)
    {
        serverIDs[i]=servers[i]->getId();
    }

    for(int i = 0; i <playerCount;i++)
    {
        playerIDs[i]=players[i]->getId();
        playerSRV[i]=players[i]->getServerID();
    }


    for(int i = 0;i<this->numberOfBuckets;i++)
    {
        indexArray[i][0]=0;
        indexArray[i][1]=this->numberOfServersInArray;
    }

    int pocet = 0;
    int line;
    for(int i =0;i<serverCount;i++)
    {
        line = serverIDs[i]/this->numberOfServersInArray;
        srvArray[line][indexArray[line][0]]=serverIDs[i];//rozdelovani serveru do jednotlivych prihradek
        indexArray[line][0]+=1;


        if(indexArray[line][0]==indexArray[line][1])
        {
            srvArray[line]=enlarge(srvArray[line],line,indexArray[line][1],indexArray[line][1]*2);//pripadny enlarge
        }
    }
}

void HashTable::Hash()
{
    int tuples = 0;//pocet nalezenych shod
    int lineToSearch;//radek ve kterem se ma vyhledavat
    for(int i = 0; i<playerCount;i++)
    {
        lineToSearch = playerSRV[i]/this->numberOfServersInArray;
        for(int j =0;j< indexArray[lineToSearch][0];j++)
        {
            if(playerSRV[i]==srvArray[lineToSearch][j])
            {
                //checkIfCorrect(srvArray[lineToSearch][j],playerIDs[i]);
                tuples++;
                break;
            }
        }
    }
    std::cout<<"finished partitioned hash join, tuples found: " << tuples <<std::endl;
}

int* HashTable::enlarge(int *pole,int line, const unsigned int currentLength, const unsigned int newLength)
{
        int *tmp = new int[newLength];

        for (unsigned int i=0; i<currentLength; i++)
        {
                tmp[i] = pole[i];
        }
        this->indexArray[line][1] = newLength;

        delete []pole;
        return tmp;
}