TPCH_AQP_system_evaluation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from ipynb.fs.full.AQP_system import AQP_system\n",
    "from ipynb.fs.full.GK_summary import GK_summary, GK_quantile\n",
    "import math\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_table('data/lineitem_clean.csv', header = 0, sep = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.sample(n=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data = data.set_index(\"ORDERKEY\", drop = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Read data\n",
    "#data = pd.read_csv('data/tpch_100000.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create system class\n",
    "class AQP_system:\n",
    "    #****System Parameters****\n",
    "    \n",
    "   \n",
    "    #numeric columns\n",
    "    #numeric_columns = []\n",
    "    #categorical columns\n",
    "    #categorical_columns = []\n",
    "    #total allowed space (proportion of underlying data)\n",
    "    #total_allowed_space = None\n",
    "    #remaining space (used when initializing meetadata0)\n",
    "    #remaining_space = None\n",
    "    #max quantile rank error\n",
    "    #quantile_error = None\n",
    "    #histogram min number of buckets (power of nrows in data)\n",
    "    #histogram_min_size = None\n",
    "    #max sample+seek distribution error\n",
    "    #sample_error = None\n",
    "    #indicator to use stdev-weighred sample sizes\n",
    "    #stdev_option = False\n",
    "    #indicator to use column storage in measure biased samples only for predicate columns correlated to the measure\n",
    "    #correlated_column_storage_option = False\n",
    "    #indicator to store selectivites of each categorical variable in each sample table or not\n",
    "    #column_selectivity_map_option = False\n",
    "    #indicator to allocate extra space (above minimum needed to guaruntee GK and sample+seek errors) to histograms/samples \n",
    "    #based on a-priori knowledge of the query workload or not)\n",
    "    #know_queries_in_advance = False\n",
    "    #workload of queries\n",
    "    #workload = []\n",
    "    #uniform\n",
    "    #include uniform sample for count or not\n",
    "   \n",
    "    \n",
    "    #****System Metadata****\n",
    "    #nrows data\n",
    "    #N = None\n",
    "    #GK_summaries_map = {}\n",
    "    #stdev_map = {}\n",
    "    #uniform_sample = None\n",
    "    #uniform_sample_selectivity_map = {}\n",
    "    #correlated_columns_for_samples_map = {}\n",
    "    #min_rows_sample_table = None\n",
    "    #histogram_map = {}\n",
    "    #measure_biased_samples_map = {}\n",
    "    #measure_biased_samples_selectivity_map = {}\n",
    "    \n",
    "    \n",
    "    \n",
    "    #init\n",
    "    def __init__(self, data, numeric_columns, categorical_columns, total_allowed_space, histogram_min_size=None, quantile_error=None, sample_error=None, uniform=False,stdev_option=False, \n",
    "                correlated_column_storage_option=False, column_selectivity_map_option=False, know_queries_in_advance=False, workload=None):\n",
    "        \n",
    "        #initialize required parameters\n",
    "        self.N = data.shape[0]\n",
    "        self.numeric_columns = numeric_columns;\n",
    "        self.categorical_columns = categorical_columns;\n",
    "        self.total_allowed_space = total_allowed_space\n",
    "        \n",
    "        #note: changing space away from proportion to number of entries\n",
    "        print (\"Total Size\" + str(data.shape[0]*data.shape[1]))\n",
    "        self.remaining_space = data.shape[0]*data.shape[1]*total_allowed_space\n",
    "        print (\"Remaining Space\" + str(self.remaining_space))\n",
    "        \n",
    "        #initialize optional parameters\n",
    "            \n",
    "        self.know_queries_in_advance = False;\n",
    "        if (know_queries_in_advance):\n",
    "            self.know_queries_in_advance = know_queries_in_advance\n",
    "            self.workload = workload\n",
    "        \n",
    "        #initialize metadata\n",
    "        self.measure_biased_samples_map = {}\n",
    "        \n",
    "        if (quantile_error!=None):\n",
    "            self.GK_summaries_map = {}\n",
    "            self.quantile_error = quantile_error\n",
    "            self.initialize_GK_summaries(data);\n",
    "            self.remaining_space = self.remaining_space-self.get_GK_size()\n",
    "        \n",
    "        self.stdev_option = stdev_option\n",
    "        if (stdev_option): \n",
    "            self.initialize_stdev_map (data)\n",
    "            self.remaining_space = self.remaining_space-len(stdev_map.values())\n",
    "        \n",
    "        #no space addition, should get deleted after initialization\n",
    "        self.correlated_column_storage_option = correlated_column_storage_option\n",
    "        if(correlated_column_storage_option): \n",
    "            self.initialize_correlated_columns_for_samples_map (data)\n",
    "            self.remaining_space = self.remaining_space-len(correlated_columns_for_samples_map.values())\n",
    "        \n",
    "        if (sample_error != None):\n",
    "            self.sample_error = sample_error\n",
    "            self.min_rows_sample_table = math.sqrt(self.N)\n",
    "            self.min_rows_sample_table =self.min_rows_sample_table/(self.sample_error)**2\n",
    "            self.min_rows_sample_table=int(self.min_rows_sample_table)\n",
    "            self.min_sample_size = self.get_min_sample_size(N=data.shape[0], data=data)\n",
    "            self.remaining_space = self.remaining_space - self.min_sample_size\n",
    "        \n",
    "        if (histogram_min_size != None):\n",
    "            self.histogram_map = {}\n",
    "            self.histogram_min_size = histogram_min_size\n",
    "            min_histogram_size = (data.shape[0]*histogram_min_size)*len(self.numeric_columns)\n",
    "            self.remaining_space = self.remaining_space - min_histogram_size\n",
    "            \n",
    "        remaining_space_distribution = self.get_remaining_space_distribution();\n",
    "        \n",
    "        if (histogram_min_size != None):\n",
    "            self.histogram_total_space = min_histogram_size + remaining_space_distribution['Range']*self.remaining_space\n",
    "            self.initialize_histograms(data, self.histogram_total_space)\n",
    "        \n",
    "        if (sample_error != None):\n",
    "            measure_biased_samples_extra_space = remaining_space_distribution['Sum+Predicate']*self.remaining_space\n",
    "            self.measure_biased_samples_space= self.min_sample_size + measure_biased_samples_extra_space\n",
    "            self.initialize_measure_biased_samples (data, measure_biased_samples_extra_space)\n",
    "        \n",
    "        if (uniform):\n",
    "            uniform_sample_extra_space = remaining_space_distribution['Count']*self.remaining_space\n",
    "            self.initialize_uniform_sample(data, uniform_sample_extra_space)\n",
    "            \n",
    "        if (column_selectivity_map_option): \n",
    "            self.column_selectivity_map_option = column_selectivity_map_option\n",
    "            self.initialize_measure_biased_samples_selectivity_map()\n",
    "            self.initialize_uniform_sample_selectivity_map (data)\n",
    "    \n",
    "\n",
    "    #Initializes all metada for the system to process queries on the underlying data\n",
    "    def initialize_GK_summaries(self, data):\n",
    "        for column in self.numeric_columns:\n",
    "            summary = GK_summary (data[column].to_numpy(), self.quantile_error)\n",
    "            self.GK_summaries_map[column] = summary\n",
    "    \n",
    "    #this is public also\n",
    "    def get_GK_size(self):\n",
    "        total_size = 0\n",
    "        for key in self.GK_summaries_map:\n",
    "            summary = self.GK_summaries_map[key]\n",
    "            total_size+=len(summary)\n",
    "        #*3 for tuples\n",
    "        return total_size*3\n",
    "    \n",
    "    def get_histogram_size(self):\n",
    "        return self.histogram_total_space\n",
    "    \n",
    "    def get_measure_biased_samples_size(self):\n",
    "        total_size_sample = 0\n",
    "        for key in self.measure_biased_samples_map:\n",
    "            sample = self.measure_biased_samples_map[key]\n",
    "            total_size_sample += sample.shape[0]*sample.shape[1]\n",
    "        return total_size_sample\n",
    "    \n",
    "    def initialize_stdev_map (self, data):\n",
    "        for column in self.numeric_columns:\n",
    "            self.stdev_map[column] = np.std(data[column])\n",
    "    \n",
    "    def initialize_uniform_sample (self, data, extra_space):\n",
    "        extra_rows = int(extra_space/data.shape[1])\n",
    "        #minimum size needed for error gauruntee (sample+seek)\n",
    "        self.uniform_sample = data.sample(n=self.min_rows_sample_table + extra_rows)\n",
    "        \n",
    "    def initialize_uniform_sample_selectivity_map (self, data):\n",
    "        for column in self.categorical_columns:\n",
    "            frequency_map = {}\n",
    "            for entry in self.uniform_sample[column]:\n",
    "                if (entry in frequency_map):\n",
    "                    frequency_map[entry] = frequency_map[entry] + 1\n",
    "                else:\n",
    "                    frequency_map[entry] = 1\n",
    "            self.uniform_sample_selectivity_map[column]=frequency_map\n",
    "            \n",
    "    def initialize_correlated_columns_for_samples_maps (self, data):\n",
    "        for num_column in self.numeric_columns:\n",
    "            correlated_columns_for_samples_map[num_colum] = []\n",
    "            for cat_column in self.categorical_columns:\n",
    "                ols_formula = num_column + ' ~ ' +'C(' + cat_column + ')'\n",
    "                model = ols(ols_formula, data=self.uniform_sample).fit()\n",
    "                aov_table = sm.stats.anova_lm(model, typ=2)\n",
    "                p_value=aov_table['PR(>F)']['C(' + cat_column + ')']\n",
    "                if (p_value<=.05):\n",
    "                    correlated_columns_for_samples_map[num_colum].append(cat_column)\n",
    "                    \n",
    "    def get_min_sample_size (self, N, data):\n",
    "        sample_size = 0\n",
    "        #categorical columns in samples\n",
    "        if (self.correlated_column_storage_option):\n",
    "            for key in self.correlated_columns_for_samples_map:\n",
    "                val = self.correlated_columns_for_samples_map[key]\n",
    "                sample_size += len(val)*self.min_rows_sample_table\n",
    "        else:\n",
    "            sample_size += self.min_rows_sample_table*len(self.categorical_columns)**len(self.numeric_columns)\n",
    "        return sample_size/(data.shape[0]*data.shape[1])\n",
    "    \n",
    "    def get_remaining_space_distribution(self):\n",
    "        if (self.know_queries_in_advance):\n",
    "            #count workload frequency\n",
    "            workload_frequency_map = {'Sum+Predicate':0, 'Range':0, 'Count':0}\n",
    "            total = 0\n",
    "            for query in self.workload:\n",
    "                if (query == 'Sum+Predicate' or query =='Range'  or query == 'Count'):\n",
    "                    workload_frequency_map[query] += 1\n",
    "                    total += 1\n",
    "            #normalize to a distribution\n",
    "            for key in workload_frequency_map:\n",
    "                workload_frequency_map[key] = workload_frequency_map[key]/total\n",
    "                workload_frequency_map[key] = workload_frequency_map[key]*self.remaining_space\n",
    "            return workload_frequency_map\n",
    "        else:\n",
    "            #for now, do nto allocate extra space\n",
    "            return {'Sum+Predicate': 0, 'Range': 0, 'Count': 0}\n",
    "    \n",
    "    def initialize_histograms (self, data, total_space):\n",
    "        #calculate number of buckets\n",
    "        num_bins = int(total_space);\n",
    "        \n",
    "        #initialize histogram\n",
    "        for column in self.numeric_columns:\n",
    "            measure_column = data[column].to_numpy()\n",
    "            self.histogram_map[column] = np.histogram(measure_column, bins=num_bins)\n",
    "            \n",
    "    def initialize_measure_biased_samples (self, data, extra_space):\n",
    "            #used for stdev setting\n",
    "            if (self.stdev_option):\n",
    "                total_stdev = sum(self.stdev_map.values())\n",
    "             \n",
    "            data_c = data.copy();\n",
    "            for column in self.numeric_columns:\n",
    "                #drop uncorrelated columns\n",
    "                if (self.correlated_column_storage_option):\n",
    "                    columns_to_drop = list(set(self.categorical_columns)-set(correlated_columns_for_samples_map[column]))\n",
    "                    data_c = data_c.drop(columns_to_drop)\n",
    "                    \n",
    "                measure_column = data_c[column].to_numpy()\n",
    "                sample_probabilities = measure_column\n",
    "                sample_probabilities = sample_probabilities/np.sum(sample_probabilities)\n",
    "                sample_table = None\n",
    "                if (self.stdev_option):\n",
    "                    nrow_stdev_option_proportion = stdev_map[column]/total_stdev\n",
    "\n",
    "                    #total extra rows * proportion\n",
    "                    n_rows_extra =  int(extra_space/data_c.shape[1])*nrow_stdev_option_proportion\n",
    "\n",
    "                    sample_table = data_c.sample(n = self.min_rows_sample_table+n_rows_extra, replace=True, weights= sample_probabilities)\n",
    "                    self.measure_biased_samples_map[column] = sample_table\n",
    "                else:\n",
    "                    #total number of rows/numbers of tables\n",
    "                    n_rows_extra =  int(extra_space/data_c.shape[1]/len(numeric_columns))\n",
    "                    sample_table = data_c.sample(n = self.min_rows_sample_table+n_rows_extra, replace=True, weights= sample_probabilities)\n",
    "                    self.measure_biased_samples_map[column] = sample_table\n",
    "    \n",
    "    def initialize_measure_biased_samples_selectivity_map (self):\n",
    "        for key in self.measure_biased_samples_map:\n",
    "            sample = self.measure_biased_samples_map[key]\n",
    "            column_map = {}\n",
    "            columns_to_use = self.categorical_columns\n",
    "            if (correlated_column_storage_option):\n",
    "                columns_to_use = correlated_columns_for_samples_map [key]\n",
    "            for column in sample.columns:\n",
    "                frequency_map = {}\n",
    "                for entry in sample[column]:\n",
    "                    if (entry in frequency_map):\n",
    "                        frequency_map[entry] = frequency_map[entry] + 1\n",
    "                    else:\n",
    "                        frequency_map[entry] = 1\n",
    "                column_map[column]=frequency_map\n",
    "            self.measure_biased_speedup_map[key] = column_map\n",
    "    #Public:\n",
    "    \n",
    "    def approximate_query (self,query):\n",
    "        query_type = query[0];\n",
    "        if (query_type == 'Quantile'):\n",
    "            column = query[1];\n",
    "            quantile = query[2];\n",
    "            \n",
    "            summary = self.GK_summaries_map[column];\n",
    "            estimate = GK_quantile (summary, self.quantile_error, quantile, self.N)\n",
    "            return estimate\n",
    "        #find proporiton of elements greater thana . valu\n",
    "        elif (query_type  == \"Range\"):\n",
    "            column = query[1];\n",
    "            value = query[2];\n",
    "\n",
    "            hist = self.histogram_map[column]\n",
    "            elements = hist[0]\n",
    "            buckets = hist[1]\n",
    "            sum_index = 0\n",
    "            max_error = 0\n",
    "            for j in range (1,len(buckets)):\n",
    "                if (buckets[j]>=value):\n",
    "                    sum_index = j\n",
    "                    max_error = elements[j-1]\n",
    "                    break\n",
    "\n",
    "            sum_buckets = 0\n",
    "            for k in range (len(elements)):\n",
    "                if (k>=(sum_index-1)):\n",
    "                    sum_buckets += elements[k]\n",
    "            estimate = sum_buckets;\n",
    "            return [estimate, max_error]\n",
    "        elif (query_type == \"Sum+Predicate\"):\n",
    "            numeric = query[1]\n",
    "            categorical = query[2]\n",
    "            sample = self.measure_biased_samples_map [numeric]\n",
    "            estimated_distribution = {}\n",
    "            total = 0\n",
    "            for predicate in sample[categorical]:\n",
    "                if (predicate not in estimated_distribution):\n",
    "                    estimated_distribution[predicate] = 1\n",
    "                else:  \n",
    "                    estimated_distribution[predicate] += 1\n",
    "                total += 1\n",
    "            for key in estimated_distribution:\n",
    "                estimated_distribution[key] /= total\n",
    "            return estimated_distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#full data parameters\n",
    "#numeric_columns = ['L_QUANTITY', 'L_EXTENDEDPRICE', 'L_DISCOUNT', 'L_TAX', 'C_ACCTBAL', 'O_TOTALPRICE', 'P_SIZE', \n",
    "                     #'#P_RETAILPRICE', 'PS_AVAILQTY', 'PS_SUPPLYCOST', 'S_ACCTBAL']\n",
    "\n",
    "#categorical_columns = ['L_ORDERKEY', 'L_PARTKEY', 'L_SUPPKEY', 'L_LINENUMBER', 'L_RETURNFLAG', \n",
    "                       #'L_LINESTATUS', 'L_SHIPDATE', 'L_COMMITDATE', 'L_RECEIPTDATE', 'L_SHIPINSTRUCT', \n",
    "                       #'L_SHIPMODE', 'C_CUSTKEY', 'C_NAME', 'C_ADDRESS', 'C_NATIONKEY', 'C_PHONE', \n",
    "                       #'C_MKTSEGMENT', 'O_ORDERKEY', 'O_CUSTKEY', 'O_ORDERSTATUS', 'O_ORDERDATE', \n",
    "                       #'O_ORDERPRIORITY', 'O_CLERK', 'O_SHIPPRIORITY', 'P_PARTKEY', 'P_NAME', 'P_MFGR', \n",
    "                       #'P_BRAND', 'P_TYPE', 'P_CONTAINER', 'PS_PARTKEY', 'PS_SUPPKEY', 'S_SUPPKEY', 'S_NAME', \n",
    "                       #'S_ADDRESS', 'S_NATIONKEY', 'S_PHONE', 'N1_NATIONKEY', 'N1_NAME', 'N1_REGIONKEY', \n",
    "                       #'N2_NATIONKEY', 'N2_NAME', 'N2_REGIONKEY', 'R1_REGIONKEY', 'R1_NAME', 'R2_REGIONKEY', \n",
    "                       #'R2_NAME']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "#lineitem parameters\n",
    "numeric_columns = ['LINENUMBER', 'QUANTITY', 'EXTENDEDPRICE', 'DISCOUNT', \n",
    "                               'TAX']\n",
    "categorical_columns = ['RETURNFLAG', 'LINESTATUS', 'SHIPINSTRUCT', 'SHIPMODE']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evaluation 1.1: GK alon\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create one system to evaluate quantiles\n",
    "total_allowed_space = .1\n",
    "quantile_error = .25\n",
    "system_1 = AQP_system(data, numeric_columns, categorical_columns, total_allowed_space, quantile_error=quantile_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "system_1 = AQP_system(data, numeric_columns, categorical_columns, total_allowed_space, quantile_error=quantile_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create a query\n",
    "quantile = .5\n",
    "column = 'LINENUMBER'\n",
    "query = ['Range', column, quantile]\n",
    "#estimate that query\n",
    "estimate = system_1.approximate_query(query)\n",
    "print (estimate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get sorted columns for error\n",
    "data_copy = data.copy()\n",
    "sorted_columns = {}\n",
    "for column in numeric_columns:\n",
    "   cur_column = data_copy[column]\n",
    "   cur_column = cur_column.to_numpy()\n",
    "   cur_column.sort()\n",
    "   sorted_columns [column] = cur_column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Built system for error 0.25\n",
      "Example 0\n",
      "Example 1\n",
      "Example 2\n",
      "Example 3\n",
      "Example 4\n",
      "Example 5\n",
      "Example 6\n",
      "Example 7\n",
      "Example 8\n",
      "Example 9\n",
      "Example 10\n",
      "Example 11\n",
      "Example 12\n",
      "Example 13\n",
      "Example 14\n",
      "Example 15\n",
      "Example 16\n",
      "Example 17\n",
      "Example 18\n",
      "Example 19\n",
      "Example 20\n",
      "Example 21\n",
      "Example 22\n",
      "Example 23\n",
      "Example 24\n",
      "Example 25\n",
      "Example 26\n",
      "Example 27\n",
      "Example 28\n",
      "Example 29\n",
      "Example 30\n",
      "Example 31\n",
      "Example 32\n",
      "Example 33\n",
      "Example 34\n",
      "Example 35\n",
      "Example 36\n",
      "Example 37\n",
      "Example 38\n",
      "Example 39\n",
      "Example 40\n",
      "Example 41\n",
      "Example 42\n",
      "Example 43\n",
      "Example 44\n",
      "Example 45\n",
      "Example 46\n",
      "Example 47\n",
      "Example 48\n",
      "Example 49\n",
      "Example 50\n",
      "Example 51\n",
      "Example 52\n",
      "Example 53\n",
      "Example 54\n",
      "Example 55\n",
      "Example 56\n",
      "Example 57\n",
      "Example 58\n",
      "Example 59\n",
      "Example 60\n",
      "Example 61\n",
      "Example 62\n",
      "Example 63\n",
      "Example 64\n",
      "Example 65\n",
      "Example 66\n",
      "Example 67\n",
      "Example 68\n",
      "Example 69\n",
      "Example 70\n",
      "Example 71\n",
      "Example 72\n",
      "Example 73\n",
      "Example 74\n",
      "Example 75\n",
      "Example 76\n",
      "Example 77\n",
      "Example 78\n",
      "Example 79\n",
      "Example 80\n",
      "Example 81\n",
      "Example 82\n",
      "Example 83\n",
      "Example 84\n",
      "Example 85\n",
      "Example 86\n",
      "Example 87\n",
      "Example 88\n",
      "Example 89\n",
      "Example 90\n",
      "Example 91\n",
      "Example 92\n",
      "Example 93\n",
      "Example 94\n",
      "Example 95\n",
      "Example 96\n",
      "Example 97\n",
      "Example 98\n",
      "Example 99\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Built system for error 0.25\n",
      "Example 0\n",
      "Example 1\n",
      "Example 2\n",
      "Example 3\n",
      "Example 4\n",
      "Example 5\n",
      "Example 6\n",
      "Example 7\n",
      "Example 8\n",
      "Example 9\n",
      "Example 10\n",
      "Example 11\n",
      "Example 12\n",
      "Example 13\n",
      "Example 14\n",
      "Example 15\n",
      "Example 16\n",
      "Example 17\n",
      "Example 18\n",
      "Example 19\n",
      "Example 20\n",
      "Example 21\n",
      "Example 22\n",
      "Example 23\n",
      "Example 24\n",
      "Example 25\n",
      "Example 26\n",
      "Example 27\n",
      "Example 28\n",
      "Example 29\n",
      "Example 30\n",
      "Example 31\n",
      "Example 32\n",
      "Example 33\n",
      "Example 34\n",
      "Example 35\n",
      "Example 36\n",
      "Example 37\n",
      "Example 38\n",
      "Example 39\n",
      "Example 40\n",
      "Example 41\n",
      "Example 42\n",
      "Example 43\n",
      "Example 44\n",
      "Example 45\n",
      "Example 46\n",
      "Example 47\n",
      "Example 48\n",
      "Example 49\n",
      "Example 50\n",
      "Example 51\n",
      "Example 52\n",
      "Example 53\n",
      "Example 54\n",
      "Example 55\n",
      "Example 56\n",
      "Example 57\n",
      "Example 58\n",
      "Example 59\n",
      "Example 60\n",
      "Example 61\n",
      "Example 62\n",
      "Example 63\n",
      "Example 64\n",
      "Example 65\n",
      "Example 66\n",
      "Example 67\n",
      "Example 68\n",
      "Example 69\n",
      "Example 70\n",
      "Example 71\n",
      "Example 72\n",
      "Example 73\n",
      "Example 74\n",
      "Example 75\n",
      "Example 76\n",
      "Example 77\n",
      "Example 78\n",
      "Example 79\n",
      "Example 80\n",
      "Example 81\n",
      "Example 82\n",
      "Example 83\n",
      "Example 84\n",
      "Example 85\n",
      "Example 86\n",
      "Example 87\n",
      "Example 88\n",
      "Example 89\n",
      "Example 90\n",
      "Example 91\n",
      "Example 92\n",
      "Example 93\n",
      "Example 94\n",
      "Example 95\n",
      "Example 96\n",
      "Example 97\n",
      "Example 98\n",
      "Example 99\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Built system for error 0.25\n",
      "Example 0\n",
      "Example 1\n",
      "Example 2\n",
      "Example 3\n",
      "Example 4\n",
      "Example 5\n",
      "Example 6\n",
      "Example 7\n",
      "Example 8\n",
      "Example 9\n",
      "Example 10\n",
      "Example 11\n",
      "Example 12\n",
      "Example 13\n",
      "Example 14\n",
      "Example 15\n",
      "Example 16\n",
      "Example 17\n",
      "Example 18\n",
      "Example 19\n",
      "Example 20\n",
      "Example 21\n",
      "Example 22\n",
      "Example 23\n",
      "Example 24\n",
      "Example 25\n",
      "Example 26\n",
      "Example 27\n",
      "Example 28\n",
      "Example 29\n",
      "Example 30\n",
      "Example 31\n",
      "Example 32\n",
      "Example 33\n",
      "Example 34\n",
      "Example 35\n",
      "Example 36\n",
      "Example 37\n",
      "Example 38\n",
      "Example 39\n",
      "Example 40\n",
      "Example 41\n",
      "Example 42\n",
      "Example 43\n",
      "Example 44\n",
      "Example 45\n",
      "Example 46\n",
      "Example 47\n",
      "Example 48\n",
      "Example 49\n",
      "Example 50\n",
      "Example 51\n",
      "Example 52\n",
      "Example 53\n",
      "Example 54\n",
      "Example 55\n",
      "Example 56\n",
      "Example 57\n",
      "Example 58\n",
      "Example 59\n",
      "Example 60\n",
      "Example 61\n",
      "Example 62\n",
      "Example 63\n",
      "Example 64\n",
      "Example 65\n",
      "Example 66\n",
      "Example 67\n",
      "Example 68\n",
      "Example 69\n",
      "Example 70\n",
      "Example 71\n",
      "Example 72\n",
      "Example 73\n",
      "Example 74\n",
      "Example 75\n",
      "Example 76\n",
      "Example 77\n",
      "Example 78\n",
      "Example 79\n",
      "Example 80\n",
      "Example 81\n",
      "Example 82\n",
      "Example 83\n",
      "Example 84\n",
      "Example 85\n",
      "Example 86\n",
      "Example 87\n",
      "Example 88\n",
      "Example 89\n",
      "Example 90\n",
      "Example 91\n",
      "Example 92\n",
      "Example 93\n",
      "Example 94\n",
      "Example 95\n",
      "Example 96\n",
      "Example 97\n",
      "Example 98\n",
      "Example 99\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Built system for error 0.25\n",
      "Example 0\n",
      "Example 1\n",
      "Example 2\n",
      "Example 3\n",
      "Example 4\n",
      "Example 5\n",
      "Example 6\n",
      "Example 7\n",
      "Example 8\n",
      "Example 9\n",
      "Example 10\n",
      "Example 11\n",
      "Example 12\n",
      "Example 13\n",
      "Example 14\n",
      "Example 15\n",
      "Example 16\n",
      "Example 17\n",
      "Example 18\n",
      "Example 19\n",
      "Example 20\n",
      "Example 21\n",
      "Example 22\n",
      "Example 23\n",
      "Example 24\n",
      "Example 25\n",
      "Example 26\n",
      "Example 27\n",
      "Example 28\n",
      "Example 29\n",
      "Example 30\n",
      "Example 31\n",
      "Example 32\n",
      "Example 33\n",
      "Example 34\n",
      "Example 35\n",
      "Example 36\n",
      "Example 37\n",
      "Example 38\n",
      "Example 39\n",
      "Example 40\n",
      "Example 41\n",
      "Example 42\n",
      "Example 43\n",
      "Example 44\n",
      "Example 45\n",
      "Example 46\n",
      "Example 47\n",
      "Example 48\n",
      "Example 49\n",
      "Example 50\n",
      "Example 51\n",
      "Example 52\n",
      "Example 53\n",
      "Example 54\n",
      "Example 55\n",
      "Example 56\n",
      "Example 57\n",
      "Example 58\n",
      "Example 59\n",
      "Example 60\n",
      "Example 61\n",
      "Example 62\n",
      "Example 63\n",
      "Example 64\n",
      "Example 65\n",
      "Example 66\n",
      "Example 67\n",
      "Example 68\n",
      "Example 69\n",
      "Example 70\n",
      "Example 71\n",
      "Example 72\n",
      "Example 73\n",
      "Example 74\n",
      "Example 75\n",
      "Example 76\n",
      "Example 77\n",
      "Example 78\n",
      "Example 79\n",
      "Example 80\n",
      "Example 81\n",
      "Example 82\n",
      "Example 83\n",
      "Example 84\n",
      "Example 85\n",
      "Example 86\n",
      "Example 87\n",
      "Example 88\n",
      "Example 89\n",
      "Example 90\n",
      "Example 91\n",
      "Example 92\n",
      "Example 93\n",
      "Example 94\n",
      "Example 95\n",
      "Example 96\n",
      "Example 97\n",
      "Example 98\n",
      "Example 99\n"
     ]
    }
   ],
   "source": [
    "#Test on a range of examples:\n",
    "#error and size for various user e\n",
    "total_allowed_space = .1\n",
    "n_examples = 100\n",
    "columns_to_test = np.random.choice (numeric_columns, n_examples, replace = True)\n",
    "quantile = .5\n",
    "errors = [.05, .1, .2, .25]\n",
    "results_map = {}\n",
    "for e in errors:\n",
    "    total_error = 0\n",
    "    system_1 = AQP_system(data, numeric_columns, categorical_columns, total_allowed_space, quantile_error=e)\n",
    "    #maps error level to (size, total error)\n",
    "    results_map[e]=[system_1.get_GK_size(), 0]\n",
    "    print (\"Built system for error \" + str(quantile_error))\n",
    "    for i in range (n_examples):\n",
    "        print (\"Example \" + str(i))\n",
    "        column = columns_to_test[i]\n",
    "        query = ['Quantile', column, quantile]\n",
    "        \n",
    "        #estimate that query\n",
    "        estimate = system_1.approximate_query(query)\n",
    "        sorted_column = sorted_columns[column]\n",
    "        \n",
    "        #find ranks of estimate \n",
    "        estimate_ranks = []\n",
    "        for i in range (len(sorted_column)):\n",
    "            if (sorted_column[i]==estimate):\n",
    "                estimate_ranks.append(i)\n",
    "            \n",
    "        if (len(estimate_ranks) == 0):\n",
    "            estimate_ranks = [len(sorted_column)]\n",
    "        \n",
    "        #find the smallest distance between an estimate rank and the actual rank, calculate rank error\n",
    "        errors = []\n",
    "        for entry in estimate_ranks:\n",
    "            errors.append(abs(entry - quantile*len(sorted_column))/len(sorted_column))\n",
    "        total_error += np.amin (errors)\n",
    "    results_map[e][1] = total_error/(n_examples)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0.05: [2760, 0.027254], 0.1: [1818, 0.04517799999999998], 0.2: [1374, 0.08765899999999997], 0.25: [1146, 0.12357199999999997]}\n"
     ]
    }
   ],
   "source": [
    "print (results_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11c358668>]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([results_map[key][0] for key in results_map.keys()],[results_map[key][1] for key in results_map.keys()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11a57c898>]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3yV9f3+8debQAJhhL0JEDbIksOqE5WKE7UoiHvXqv35ta3V2mGxbq1awYG4LWJrtUUEcYDiYAUQkLBCCBDCDoQRMs/n90cO7TEmcgIn5z45uZ6PRx6cc+5xrnOfmyt3Puec+5hzDhERiV21vA4gIiJVS0UvIhLjVPQiIjFORS8iEuNU9CIiMa621wHKat68uevUqZPXMUREqpUlS5bsds61KG9a1BV9p06dSE1N9TqGiEi1YmabKpqmoRsRkRinohcRiXEqehGRGKeiFxGJcSp6EZEYp6IXEYlxKnoRkRinohcRiQIfr9rO+8uyqmTdKnoREY/NWJHNL/6+lLcWbKbEH/7vCFHRi4h46L2lWfzy7WUMTG7Ma9cNJq6Whf0+ou4UCCIiNcW0RZu59/2VDE9pxpRrfCTGV00lq+hFRDzwxvxM/vifVZzWvQUvXjWIunXiquy+Qhq6MbNRZrbWzNLN7J5ypp9qZkvNrNjMxgTdPsDM5pvZKjNbYWZjwxleRKQ6emleBn/8zyrO6tWKyVdXbclDCEVvZnHAJOAcoDdwuZn1LjPbZuBaYGqZ2/OAq51zfYBRwNNm1vh4Q4uIVFcT56znwZmrOa9vG56/8kQSaldtyUNoQzdDgHTnXAaAmU0DRgNpR2ZwzmUGpvmDF3TOrQu6nG1mO4EWwL7jTi4iUo045/jrJ+t4dk46Fw1oyxOX9qd2XGTeDxPKvbQDtgRdzwrcVilmNgSIBzZUdlkRkerMOccjs9bw7Jx0xvo68ORlAyJW8hBa0Zf3Xp9KvdHTzNoAbwLXOef85Uy/2cxSzSx1165dlVm1iEhU8/sdf/4gjRfnZXDVsI48fEnfKnkL5Y8JpeizgA5B19sD2aHegZk1Aj4Efu+cW1DePM65yc45n3PO16JFud+EJSJS7fj9jvv+vZLXvsnkhpM7M2F0H2pFuOQhtKJfDHQzs85mFg+MA6aHsvLA/O8Dbzjn/nnsMUVEqpcSv+PX7y7n7UVbuG1EF35/Xi/MIl/yEELRO+eKgduB2cBq4B/OuVVmNsHMLgQws8FmlgVcCrxoZqsCi18GnApca2bfBn4GVMkjERGJEkUlfv7ftGW8t3Qrd43szm/O7ulZyQOYc+E/r8Lx8Pl8Tl8OLiLVVUFxCXdMXcbHaTu455ye/Py0LhG5XzNb4pzzlTdNn4wVEQmT/KISbn1rCXPX7uJPF/TmupM6ex0JUNGLiITF4cISbnojla837Oahi/syfmiy15H+S0UvInKcDhYUc/1ri0nNzOHxMf0ZM6i915G+R0UvInIccg8Xce2ri1iRlctTYwcwekClP09a5VT0IiLHaF9eIVe9vIg12/czafxARp3QxutI5VLRi4gcg90HC7hyykIydh/ixasGcUbPVl5HqpCKXkSkknbuz2f8lIVk7c1jytU+Tu0e3Z/oV9GLiFRC9r7DjH9pATsPFPDadUMYltLM60hHpaIXEQnRlpw8Ln9pAbl5Rbx5wxAGdWzqdaSQqOhFREKwcfchxr+0gLzCEv5+01D6ta8+36GkohcROYr1Ow4wfspCSvyOt28aRu+2jbyOVCkqehGRH7F6236unLKQWrWMd24eRrdWDb2OVGmR+4oTEZFqZmVWLpe/tIA6cbWqbcmDil5EpFxLNu1l/EsLqB9fm3/cMpyUFg28jnTMNHQjIlLGwow9XP/aYlo0TODvNw2jXeN6Xkc6Lip6EZEgX63fzY1vLKZd43pMvWkYrRrV9TrScVPRi4gEzF2zk1veWkJK8/q8deNQmjdI8DpSWKjoRUSA2au2c/vUpfRo3ZA3rx9Kk/rxXkcKGxW9iNR4HyzP5s53vqVvuyRev34ISfXqeB0prFT0IlKjvbc0i1//czm+jk155brBNEiIvVqMvUckIhKitxdt5nfvr2R4SjOmXOMjMT42KzE2H5WIyFG8/k0mf5q+itN7tOCFKwdRt06c15GqjIpeRGqcl+Zl8ODM1Yzs3YqJ4weSUDt2Sx5U9CJSwzz72Xqe/GQd5/Vtw9PjBlAnLvZPEKCiF5EawTnHkx+vY+LcdC4Z2I7HxvSjdg0oeVDRi0gN4Jzj4VlrmDwvg3GDO/DgxX2Jq2Vex4oYFb2IxDS/3/HnD1bx+vxNXD28I/df0IdaNajkQUUvIjHM73fc9++VvL1oCzed0pnfndsLs5pV8qCiF5EYVVzi5+53V/Desq3cPqIrv/pp9xpZ8qCiF5EYVFTi5//e+ZYZK7bxq5HduePMbl5H8pSKXkRiSkFxCXdMXcbHaTu495ye3HJaF68jeU5FLyIxI7+ohJ+/tYTP1+7i/gt6c+1Jnb2OFBVCehOpmY0ys7Vmlm5m95Qz/VQzW2pmxWY2psy0a8xsfeDnmnAFFxEJlldYzI2vp/LFul08dHFflXyQox7Rm1kcMAkYCWQBi81sunMuLWi2zcC1wK/LLNsU+BPgAxywJLDs3vDEFxGBgwXFXP/aYlIzc3h8TH/GDGrvdaSoEsoR/RAg3TmX4ZwrBKYBo4NncM5lOudWAP4yy54NfOKcywmU+yfAqDDkFhEBIPdwEVe9vJAlm/byzLiBKvlyhFL07YAtQdezAreF4niWFRH5UXsPFXLFlAV8tzWXSeNP5IL+bb2OFJVCKfry3njqQlx/SMua2c1mlmpmqbt27Qpx1SJSk+0+WMDlLy1g3Y6DvHjVIEad0NrrSFErlKLPAjoEXW8PZIe4/pCWdc5Nds75nHO+Fi1ahLhqEampduzPZ9zkBWTuOcQr1wzmjJ6tvI4U1UIp+sVANzPrbGbxwDhgeojrnw381MyamFkT4KeB20REjkn2vsOMfXE+2/Yd5vXrhnByt+ZeR4p6Ry1651wxcDulBb0a+IdzbpWZTTCzCwHMbLCZZQGXAi+a2arAsjnAA5T+slgMTAjcJiJSaVty8rjsxfnsOVjIGzcMZWhKM68jVQvmXKjD7ZHh8/lcamqq1zFEJMps3H2I8S8tIK+whDdvGEK/9o29jhRVzGyJc85X3jR9MlZEot76HQcYP2Uhfr/j7ZuG0bttI68jVSsqehGJamnZ+7ny5YXE1TKm3TyMbq0aeh2p2lHRi0jUWpG1j6teXkRifBxTbxpG5+b1vY5ULanoRSQqLdm0l2tfWURSYh3evmkYHZomeh2p2lLRi0jUWZixh+tfW0yLhglMvWkYbRvX8zpStaaiF5Go8tX63dz4xmLaN0lk6o1DadmorteRqj0VvYhEjblrdnLLW0tIaV6ft24cSvMGCV5HigkqehGJCh99t5073l5Kz9aNeOP6ITSpH+91pJihohcRz32wPJs73/mWfu2TeO26ISTVq+N1pJiiohcRT/1rSRa/eXc5vo5NeeW6wTRIUC2Fm7aoiHjm7UWb+d37KzmpS3MmXz2IxHhVUlXQVhURT7z+TSZ/mr6KET1a8PyVg6hbJ87rSDFLRS8iETd53gYemrmGn/ZuxbPjB5JQWyVflVT0IhJRz362nic/Wcf5/drw1NgB1IkL5Wsx5Hio6EUkIpxzPPnxOibOTeeSE9vx+Jj+xNUq79tGJdxU9CJS5ZxzPDRzNS99uZFxgzvw0MV9qaWSjxgVvYhUKb/fcf8Hq3hj/iauGd6RP13QRyUfYSp6Eakyfr/jd++vZNriLdx8agr3ntMTM5V8pKnoRaRKFJf4ufvdFby3bCt3nNGVu0Z2V8l7REUvImG3JSePP/7nO+au3cWvRnbnjjO7eR2pRlPRi0jYHCwo5rm56Uz5aiNxZkwY3Yerh3fyOlaNp6IXkePm9zv+tTSLx2avZdeBAi4Z2I7fjOpBmyR9YUg0UNGLyHFZnJnDhA/SWLk1l4HJjZl81SAGJjfxOpYEUdGLyDHJ2pvHI7PWMGPFNtok1eWZcQO4sH9bveAahVT0IlIphwqKeeGLDUyel4EZ/L8zu3HLaSk682QU0zMjIiHx+x3vL9vKY7PXsGN/AaMHtOW3o3rqi7urARW9iBzVkk17mTAjjeVb9tG/fRLPXTGIQR01Dl9dqOhFpELZ+w7zyKw1TF+eTatGCfz1sv5cNKCdTmFQzajoReQHDheW8MIXG3hx3gacg1+e0ZVbTutCfX3NX7WkZ01E/ss5x3++zebRj9awLTef8/u14Z5zetK+SaLX0eQ4qOhFBIBlm0vH4Zdt3kffdkk8e/lAfJ2aeh1LwkBFL1LDbc/N59GP1vD+sq20bJjAE5f255KBGoePJSp6kRrqcGEJk+dl8MIXGyhxjttGdOEXp3fVOHwMCukZNbNRwDNAHDDFOfdImekJwBvAIGAPMNY5l2lmdYApwImB+3rDOfdwGPOLSCU55/hgxTYembma7Nx8zutbOg7foanG4WPVUYvezOKAScBIIAtYbGbTnXNpQbPdAOx1znU1s3HAo8BY4FIgwTnX18wSgTQze9s5lxnuByIiR7d8yz4mzEhjyaa99GnbiKfGDmBoSjOvY0kVC+WIfgiQ7pzLADCzacBoILjoRwP3By6/C0y00hNeOKC+mdUG6gGFwP7wRBeRUO3YXzoO/97SrTRvkMBjP+vHzwa115dz1xChFH07YEvQ9SxgaEXzOOeKzSwXaEZp6Y8GtgGJwP8553LK3oGZ3QzcDJCcnFzJhyAiFckvKmHKlxk89/kGikscPz+tC7eN6ELDunW8jiYRFErRl/cr34U4zxCgBGgLNAG+NLNPj/x18N8ZnZsMTAbw+Xxl1y0ileSc48OV23h45hq27jvMqD6t+d25vUhupnH4miiUos8COgRdbw9kVzBPVmCYJgnIAcYDHznnioCdZvY14AMyEJEq8d3WXCZ8kMaizBx6tWnEE5f2Z3gXjcPXZKEU/WKgm5l1BrYC4ygt8GDTgWuA+cAYYI5zzpnZZuAMM3uL0qGbYcDT4QovIv+z80A+j3+0lneXZtE0MZ6HL+nLZb4OGoeXoxd9YMz9dmA2pW+vfMU5t8rMJgCpzrnpwMvAm2aWTumR/LjA4pOAV4HvKB3eedU5t6IKHodIjZVfVMLLX23kubnpFJb4ufmUFG47oyuNNA4vAeZcdA2J+3w+l5qa6nUMkajnnOOj77bz0KzVbMk5zMjerbjv3F50al7f62jiATNb4pzzlTdNH4ETqYZWZZeOwy/cmEPP1g35+41DOalrc69jSZRS0YtUI7sOFPDkx2t5J3ULTRLjefDiExjr60DtuFpeR5MopqIXqQYKikt49etMJs5JJ7+ohBtO6swdZ3YjqZ7G4eXoVPQiUcw5x8dpO3ho5mo27cnjrF4t+d25vUhp0cDraFKNqOhFotTqbfuZ8EEa8zP20L1VA968YQindGvhdSyphlT0IlFm98ECnvx4He8s3kxSvTo8MLoPlw9J1ji8HDMVvUiUKCz28/o3mfzts/UcLirhmp904s4zu5OUqHF4OT4qehGPOef4dPVOHvwwjcw9eYzo0YL7zutN15Yah5fwUNGLeGjt9gM8MCONr9J307VlA167bjCn92jpdSyJMSp6EQ/kHCrkr5+sZerCzTSsW4f7L+jNFcM6Ukfj8FIFVPQiEVRY7OfNBZt45tN1HCos4erhnbjzrG40Toz3OprEMBW9SAQ455i7did/mbGajN2HOK17C/5wfi+6tmzodTSpAVT0IlVs/Y4DTJiRxpfrd5PSoj6vXjuYET01Di+Ro6IXqSJ7DxXy9KfreGvhZurHx/HH83tz1XCNw0vkqehFwqyoxM9bCzbx9KfrOZBfxBVDO/J/I7vTtL7G4cUbKnqRMPp87U7+8uFq0nce5JRuzfn9eb3p0Vrj8OItFb1IGKTvPMhfPkzj87W76Ny8PlOu9nFmr5aY6Wv8xHsqepHjsC+vkKc/Xc9bCzZRLz6O35/Xi6uHdyK+tsbhJXqo6EWOQXGJn6mLNvPXT9ax/3ARlw9J5q6R3WnWIMHraCI/oKIXqaR563bxwIw01u88yE+6NOMP5/emV5tGXscSqZCKXiREGbsO8uCHq/lszU46Nktk8lWDGNm7lcbhJeqp6EWOIvdwEX/7bD2vf5NJ3Tpx3HtOT649qRMJteO8jiYSEhW9SAWKS/xMW7yFv36yjr15hYwb3IG7RvagRUONw0v1oqIXKcfX6buZ8EEaa3ccYFhKU/5wfm/6tE3yOpbIMVHRiwTZuPsQD364mk9X76BD03q8cOWJnN2ntcbhpVpT0YsA+/OLmDgnnVe/3kh8XC1+O6on153Uibp1NA4v1Z+KXmq0Er/jncVbePLjteTkFXLZoA786uzutGxY1+toImGjopca65sNpePwa7YfYEinprx+QW9OaKdxeIk9KnqpcTbvyePBmWnMXrWDdo3rMWn8iZzbV+PwErtU9FJjHMgvYuLcdF79KpPaccZvzu7BDSd31ji8xDwVvcS8Er/j3SVbeHz2OnYfLGDMoPbcfXYPWjbSOLzUDCp6iWkLM/YwYUYaq7L34+vYhFeu9dGvfWOvY4lEVEhFb2ajgGeAOGCKc+6RMtMTgDeAQcAeYKxzLjMwrR/wItAI8AODnXP54XoAIuXZkpPHw7NWM3Pldto1rsezlw/k/H5tNA4vNdJRi97M4oBJwEggC1hsZtOdc2lBs90A7HXOdTWzccCjwFgzqw28BVzlnFtuZs2AorA/CpGAgwXFPDc3nSlfbSTOjF+N7M5Np6ZoHF5qtFCO6IcA6c65DAAzmwaMBoKLfjRwf+Dyu8BEKz10+imwwjm3HMA5tydMuUW+x+93/GtpFo/NXsuuAwVcMrAdd4/qSeskjcOLhFL07YAtQdezgKEVzeOcKzazXKAZ0B1wZjYbaAFMc849VvYOzOxm4GaA5OTkyj4GqeEWZ+Yw4YM0Vm7N5cTkxrx0tY8BHTQOL3JEKEVf3qCmC3Ge2sDJwGAgD/jMzJY45z773ozOTQYmA/h8vrLrFilX1t48Hp61hg9XbKNNUl2eGTeAC/u31Ti8SBmhFH0W0CHoensgu4J5sgLj8klATuD2L5xzuwHMbCZwIvAZIsfoUEExL3yxgcnzMjCDO8/qxi2ndqFevMbhRcoTStEvBrqZWWdgKzAOGF9mnunANcB8YAwwxzl3ZMjmbjNLBAqB04CnwhVeaha/3/H+sq08NnsNO/YXcNGAttw9qidtG9fzOppIVDtq0QfG3G8HZlP69spXnHOrzGwCkOqcmw68DLxpZumUHsmPCyy718z+SukvCwfMdM59WEWPRWLYkk2l4/DLs3Lp36Exz185iBOTm3gdS6RaMOeia0jc5/O51NRUr2NIlMjed5hHZq1h+vJsWjeqy2/P6cHo/u2oVUvj8CLBAq9/+sqbpk/GSlTKKyzmhS8ymDxvA87BL8/oys9P70JivHZZkcrS/xqJKn6/Y/rybB6ZtYbt+/O5oH9b7jmnJ+00Di9yzFT0EjWWbd7Lnz9I49st++jXPomJ4wfi69TU61gi1Z6KXjy3Lfcwj320lveXbaVlwwSeuLQ/lwzUOLxIuKjoxTOHC0uYPC+DF77YQIlz3D6iK7ee3oX6CdotRcJJ/6Mk4pwrHYd/dNYasnPzOa9fG+4Z1ZMOTRO9jiYSk1T0ElHLt+xjwow0lmzaywntGvH0uIEM6axxeJGqpKKXiNixP59HP1rDe0u30rxBAo/9rB9jBrXXOLxIBKjopUrlF5Uw5csMnvt8A8UljltP78JtI7rSQOPwIhGj/21SJZxzfLhyGw/PXMPWfYc554TW3HtOL5KbaRxeJNJU9BJ2K7NymTBjFYsz99KrTSOeuLQ/w7s08zqWSI2lopew2bk/n8dnr+XdpVk0qx/PI5f05VJfB+I0Di/iKRW9HLf8ohJe/mojz81Np6jEcfOpKdw+oisN69bxOpqIoKKX4+CcY9Z323lo5mqy9h7m7D6t+N25vejYrL7X0UQkiIpejsl3W3N5YEYaCzfm0LN1Q6beOJSfdG3udSwRKYeKXipl14ECnvx4Le+kbqFJYjwPXnwC4wYnaxxeJIqp6CUkBcUlvPp1JhPnpFNQXMKNJ3fm9jO6kVRP4/Ai0U5FLz/KOcfsVTt4aOZqNufkcVavVtx3Xi86N9c4vEh1oaKXCqVl7+eBGWnMz9hD91YNePOGIZzSrYXXsUSkklT08gO7Dxbw5MfreGfxZpLq1eGBi07g8sEdqB1Xy+toInIMVPTyX4XFfl7/JpO/fbaew0UlXHdSZ355RjeSEjUOL1KdqegF5xyfrt7Jgx+mkbknjzN6tuS+83rRpUUDr6OJSBio6Gu4Ndv385cZq/kqfTddWzbg9euHcFp3jcOLxBIVfQ21dd9hJs1NZ9qizTSqV4c/X9iH8UOTqaNxeJGYo6KvYTJ3H+L5zzfwr6VZmMHVwztx51ndaJwY73U0EakiKvoaYt2OA0yam84Hy7OpE1eLK4d15OZTU2jbuJ7X0USkiqnoY9zKrFwmzl3P7FU7qB8fx02npnDjySm0aJjgdTQRiRAVfYxasimHZ+ek8/naXTSqW5tfntmN637SiSb1NUQjUtOo6GOIc45vNuxh4px05mfsoWn9eO4e1YOrhnXUueFFajAVfQxwzjF37U6enZPOss37aNUogT+c35vLh3QgMV5PsUhNpxaoxvx+x0ertjNxTjpp2/bTvkk9Hrz4BMYMak9C7Tiv44lIlFDRV0PFJX4+WJHNpLkbSN95kJQW9Xni0v6MHtBW74MXkR8IqejNbBTwDBAHTHHOPVJmegLwBjAI2AOMdc5lBk1PBtKA+51zT4Qnes1TUFzCe0u38vznG9ick0fP1g2ZOH4g55zQRl/8ISIVOmrRm1kcMAkYCWQBi81sunMuLWi2G4C9zrmuZjYOeBQYGzT9KWBW+GLXLPlFJUxbtJkX52WwLTef/u2T+MP5Ps7s2ZJaKngROYpQjuiHAOnOuQwAM5sGjKb0CP2I0cD9gcvvAhPNzJxzzswuAjKAQ2FLXUMcLCjmrQWbmPJlBrsPFjKkc1MeG9OPk7s2x0wFLyKhCaXo2wFbgq5nAUMrmsc5V2xmuUAzMzsM/JbSvwZ+XdEdmNnNwM0AycnJIYePVbl5Rbz2TSavfL2R3MNFnNKtObeP6MrQlGZeRxORaiiUoi/v0NGFOM+fgaeccwd/7AjUOTcZmAzg8/nKrrvG2H2wgJe/2sib8zdxsKCYkb1bcfuIrvTv0NjraCJSjYVS9FlAh6Dr7YHsCubJMrPaQBKQQ+mR/xgzewxoDPjNLN85N/G4k8eQ7bn5TJ6XwdRFmygo9nNe3zbcNqIrvdo08jqaiMSAUIp+MdDNzDoDW4FxwPgy80wHrgHmA2OAOc45B5xyZAYzux84qJL/ny05eTz/xQbeTc2ixDkuHtiOW0/voi/8EJGwOmrRB8bcbwdmU/r2ylecc6vMbAKQ6pybDrwMvGlm6ZQeyY+rytDV3YZdB3lu7gb+/e1W4sy41Neen5/WhQ5NE72OJiIxyEoPvKOHz+dzqampXseoEqu37Wfi3HRmrtxGQu1aXDG0IzedkkLrpLpeRxORas7MljjnfOVN0ydjI+DbLfuYOCedT1fvoEFCbW49rQvXn9yZ5g10qmARqXoq+iq0MGMPE+em8+X63TROrMNdI7tzzfBOJCXqTJIiEjkq+jBzzvHl+t1MnJPOoswcmjeI595zenLFsI40SNDmFpHIU/OEid/v+HT1DibOTWdFVi5tkury5wv7MHZwB+rW0ZkkRcQ7KvrjVOJ3zFy5jUlz01mz/QDJTRN55JK+XHJie+Jr60ySIuI9Ff0xKirx8+9lpWeSzNh9iK4tG/DU2P5c0K8ttXWqYBGJIir6SsovKuGfS7J44fMNbN13mN5tGvH8FSdydp/WOpOkiEQlFX2I8gqLmbpwM5PnZbDzQAEDkxvzwEV9GNGjpc4kKSJRTUV/FPvzi3hz/iZe/mojOYcKGZ7SjKfHDmB4l2YqeBGpFlT0Fdh7qJBXv97Iq99kciC/mNN7tOD2EV3xdWrqdTQRkUpR0Zex80A+L3+5kTcXbCKvsIRRfVpz24iu9G2f5HU0EZFjoqIP2LrvMJO/2MC0xVsoKvFzQf+23DaiK91bNfQ6mojIcanxRb9pzyGe/3wD/1qahXPwsxPbc+vpXejUvL7X0UREwqLGFv36HQeYNDed6cuzqR1Xi8uHJHPLaV1o17ie19FERMKqxhX9d1tzmTQ3nVnfbScxPo4bT0nhxpM707KRThUsIrGpxhT9kk17mThnPXPX7qJhQm3uOKMr153Umab1472OJiJSpWK66J1zzM/Yw8Q56XyzYQ9NEuvwm7N7cNXwjjSqq1MFi0jNEJNF75zj87W7eHbOepZu3keLhgn8/rxejB+aTGJ8TD5kEZEKxVTr+f2O2au2M3FuOquy99OucT0euOgELh3UXqcKFpEaK2aKfktOHte/tpj1Ow/SqVkij43px8UD21FHZ5IUkRouZoq+dVJdkpsmcvsZXTm/X1vidCZJEREghoq+TlwtXr52sNcxRESijsY1RERinIpeRCTGqehFRGKcil5EJMap6EVEYpyKXkQkxqnoRURinIpeRCTGmXPO6wzfY2a7gE3HsYrmwO4wxQkn5aoc5aoc5aqcWMzV0TnXorwJUVf0x8vMUp1zPq9zlKVclaNclaNclVPTcmnoRkQkxqnoRURiXCwW/WSvA1RAuSpHuSpHuSqnRuWKuTF6ERH5vlg8ohcRkSAqehGRGBfVRW9mo8xsrZmlm9k95UxPMLN3AtMXmlmnwO2dzOywmX0b+HkhaJlBZrYysMzfzKzSX0V1HLmuCMr0rZn5zWxAYNrngXUemdayCnKdamZLzazYzMaUmXaNma0P/FwTdHsktle5ucxsgJnNN7NVZrbCzMYGTXvNzDYGba8BkcoVmFYSdN/Tg27vHHjO1wf2gfhI5TKzEWX2r3wzuygwLRLb6y4zSws8V5+ZWcegaV7uX+XmioL96wX/eFUAAARpSURBVMe2V3j3L+dcVP4AccAGIAWIB5YDvcvM8wvghcDlccA7gcudgO8qWO8iYDhgwCzgnEjlKjNPXyAj6PrngK+Kt1cnoB/wBjAm6PamQEbg3yaBy00iuL0qytUd6Ba43BbYBjQOXH8teN5Ibq/AtIMVrPcfwLjA5ReAWyOZq8xzmgMkRnB7jQi6v1v53/9Hr/evinJ5vX+Vm6sq9q9oPqIfAqQ75zKcc4XANGB0mXlGA68HLr8LnPljRwRm1gZo5Jyb70q31BvARR7luhx4u5L3fVy5nHOZzrkVgL/MsmcDnzjncpxze4FPgFGR2l4V5XLOrXPOrQ9czgZ2AuV+8u8YHM/2KlfgOT6D0uccSveBiG2vMsYAs5xzeZW8/+PJNTfo/hYA7QOXvd6/ys0VBftXRdurXMezf0Vz0bcDtgRdzwrcVu48zrliIBdoFpjW2cyWmdkXZnZK0PxZR1lnVec6Yiw/LPpXA3+q/eEY/oQNJVdll43U9joqMxtC6ZHRhqCbHwz82fuUmSVEOFddM0s1swVHhkcofY73BZ7zY1lnOHIdMY4f7l+R3F43UHqE/mPLerF/Bef6ryjYv8rmCuv+Fc1FX17RlX0vaEXzbAOSnXMDgbuAqWbWKMR1VmWu0olmQ4E859x3QdOvcM71BU4J/FxVBbkqu2ykttePr6D0yO9N4Drn3JGj2HuBnsBgSocEfhvhXMmu9KPq44GnzaxLGNYZjlxHtldfYHbQzRHbXmZ2JeADHj/KshHdXuXkOnK7p/tXBbnCun9Fc9FnAR2CrrcHsiuax8xqA0lAjnOuwDm3B8A5t4TS39LdA/MH/3lU3jqrLFfQ9B8cbTnntgb+PQBMpfRPv3DnquyykdpeFQr8gv4Q+L1zbsGR251z21ypAuBVIru9jvypj3Mug9LXVwZSejKqxoHnvNLrDEeugMuA951zRUF5I7K9zOws4D7gwsB9/diyEdu/Ksjl+f5VUa6w71+hDOR78QPUpvRFm87878WMPmXmuY3vv+j5j8DlFkBc4HIKsBVoGri+GBjG/178OTdSuQLXawV2gpQy62weuFyH0jG4n4c7V9C8r/HDF2M3UvpCWZPA5Yhtrx/JFQ98BtxZzrxtAv8a8DTwSARzNQESApebA+sJvNAG/JPvv1j2i0jlCrp9ATAi0tuL0jLaQOAFzmjZv34kl6f714/kCvv+FXJwL36Ac4F1gY1xX+C2CZT+9gOoG3jg6ZS+ep8SuP1nwKrAxl0KXBC0Th/wXWCdEwl8OjgSuQLTTgcWlFlffWAJsCKQ+xkCv6jCnGswpb9kDgF7gFVBy14fyJtO6Z+wkdxe5eYCrgSKgG+DfgYEps0BVgayvQU0iGCunwTue3ng3xuC1pkSeM7TA/tAQoSfx06UHtjUKrPOSGyvT4EdQc/V9CjZv8rNFQX7V0W5wr5/6RQIIiIxLprH6EVEJAxU9CIiMU5FLyIS41T0IiIxTkUvIhLjVPQiIjFORS8iEuP+Pyck7Gxncl8YAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([key for key in results_map.keys()],[results_map[key][1] for key in results_map.keys()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([0.05, 0.1, 0.2, 0.25])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_map.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evaluation 1.2: Histogram alone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Size160000\n",
      "Remaining Space16000.0\n"
     ]
    }
   ],
   "source": [
    "#create one system to evaluate histograms\n",
    "total_allowed_space = .1\n",
    "histogram_min_size = .01\n",
    "system_1 = AQP_system(data, numeric_columns, categorical_columns, total_allowed_space, histogram_min_size=histogram_min_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evaluate\n",
    "n_examples = 100\n",
    "columns_to_test = np.random.choice (numeric_columns, n_examples, replace = True)\n",
    "cur_range = .5\n",
    "sizes= [.01, .05, .1, .2, .25]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n"
     ]
    }
   ],
   "source": [
    "results_map= {}\n",
    "for min_size in sizes:\n",
    "    #size, total error, max error\n",
    "    results_map[min_size] = [0, 0, 0]\n",
    "    system_h = AQP_system(data, numeric_columns, categorical_columns, total_allowed_space, histogram_min_size=min_size)\n",
    "    results_map[min_size][0] = system_h.get_histogram_size()\n",
    "    total_error = 0\n",
    "    total_max_error = 0\n",
    "    for i in range (n_examples):\n",
    "        column = columns_to_test[i]\n",
    "        value = np.quantile (data[column].to_numpy(), cur_range)\n",
    "        query = ['Range', column, value]\n",
    "        result = system_h.approximate_query(query)\n",
    "        estimate = result[0]\n",
    "    \n",
    "        #actual count above cur_range\n",
    "        actual = (1-cur_range)*len(data[column].to_numpy())\n",
    "        inc_error = abs((actual-estimate)/len(data[column].to_numpy()))\n",
    "        max_error = result[1]/len(data[column].to_numpy())\n",
    "\n",
    "        total_error += inc_error\n",
    "        total_max_error += max_error\n",
    "    total_error = total_error/n_examples\n",
    "    total_max_error = total_max_error/n_examples\n",
    "    results_map[min_size][1] = total_error\n",
    "    results_map[min_size][2] = total_max_error\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0.01: [500.0, 0.033968000000000026, 0.05223799999999998], 0.05: [2500.0, 0.03377600000000003, 0.051973999999999985], 0.1: [5000.0, 0.03374000000000002, 0.05193799999999997], 0.2: [10000.0, 0.03374000000000002, 0.05191399999999999], 0.25: [12500.0, 0.03374000000000002, 0.07664199999999997]}\n"
     ]
    }
   ],
   "source": [
    "#minimum size:[size, total errror, max error]\n",
    "print(results_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x14bc00e80>]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([results_map[key][0] for key in results_map.keys()],[results_map[key][1] for key in results_map.keys()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1245df128>]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([results_map[key][2] for key in results_map.keys()],[results_map[key][1] for key in results_map.keys()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.01, 0.05, 0.1, 0.15, 0.2]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[key for key in results_map.keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evaluation 1.3: Sum+Predicate alone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Size160000\n",
      "Remaining Space16000.0\n"
     ]
    }
   ],
   "source": [
    "#create one system to evaluate Sum+Predicate\n",
    "total_allowed_space = .1\n",
    "sample_error = .1\n",
    "system_1 = AQP_system(data, numeric_columns, categorical_columns, total_allowed_space, sample_error=sample_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evaluate\n",
    "n_examples = 100\n",
    "numeric_columns_to_test = np.random.choice (numeric_columns, n_examples, replace = True)\n",
    "categorical_columns_to_test =  np.random.choice (categorical_columns, n_examples, replace = True)\n",
    "errors = [.1, .2, .3, .4, .5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n",
      "Total Size160000\n",
      "Remaining Space16000.0\n"
     ]
    }
   ],
   "source": [
    "results_map= {}\n",
    "for error in errors:\n",
    "    #actual eror, size\n",
    "    results_map[error] = [0, 0]\n",
    "    system_s = AQP_system(data, numeric_columns, categorical_columns, total_allowed_space, sample_error=error)\n",
    "    results_map[error][0] = system_s.get_measure_biased_samples_size();\n",
    "    total_error = 0\n",
    "    for i in range (n_examples):\n",
    "        numeric_column = numeric_columns_to_test[i]\n",
    "        categorical_column = categorical_columns_to_test[i]\n",
    "\n",
    "        query = ['Sum+Predicate', numeric_column, categorical_column]\n",
    "        estimated_distribution = system_s.approximate_query(query)\n",
    "\n",
    "        #actual distribution\n",
    "        total_actual = 0\n",
    "        actual_distribution = {}\n",
    "        for predicate in data[categorical_column]:\n",
    "            if (predicate not in actual_distribution):\n",
    "                actual_distribution[predicate] = 1\n",
    "            else:  \n",
    "                actual_distribution[predicate] += 1\n",
    "            total_actual += 1\n",
    "        for key in actual_distribution:\n",
    "            actual_distribution[key] /= total_actual\n",
    "\n",
    "        inc_error = 0\n",
    "        for key in actual_distribution:\n",
    "            inc_error += (actual_distribution[key]-estimated_distribution[key])**2\n",
    "        total_error += inc_error\n",
    "    total_error = total_error/n_examples\n",
    "    results_map[error][1] = total_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0.1: [799920, 8.064167921140758e-05], 0.2: [199920, 0.00026362640249348227], 0.3: [88880, 0.0007171312392985289], 0.4: [49920, 0.0009376897351742271], 0.5: [32000, 0.0013551531999999988]}\n"
     ]
    }
   ],
   "source": [
    "print (results_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x149cb7cf8>]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([results_map[key][0] for key in results_map.keys()],[results_map[key][1] for key in results_map.keys()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1491d7390>]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([key for key in results_map.keys()],[results_map[key][1] for key in results_map.keys()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#analyze budget size based on e for samples\n",
    "N = 10000\n",
    "e = .1\n",
    "print(int(math.sqrt(N)/(e**2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#generate random workload\n",
    "query_types = ['Stdev', 'Sum', 'Sum+Predicate', 'Quantile', 'Range', 'Count']\n",
    "random_workload = np.random.choice(query_types, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(1/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}