dbworkload 0.7.0a1__tar.gz → 0.8.2__tar.gz

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: dbworkload
-Version: 0.7.0a1
+Version: 0.8.2
 Summary: Workload framework
-Home-page: https://dbworkload.github.io/dbworkload/
 License: GPLv3+
 Author: Fabio Ghirardello
 Requires-Python: >=3.8,<4.0
@@ -45,6 +44,7 @@ Requires-Dist: pyyaml
 Requires-Dist: sqlparse
 Requires-Dist: tabulate
 Requires-Dist: typer[all]
+Project-URL: Homepage, https://dbworkload.github.io/dbworkload/
 Project-URL: Repository, https://github.com/dbworkload/dbworkload
 Description-Content-Type: text/markdown
 

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/dbworkload/cli/dep.py

@@ -1,9 +1,10 @@
 #!/usr/bin/python
 
-from .. import __version__
 import typer
 
-EPILOG = "GitHub: <https://github.com/fabiog1901/dbworkload>"
+from .. import __version__
+
+EPILOG = "Docs: <https://dbworkload.github.io/dbworkload/>"
 
 
 class ConnInfo:

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/dbworkload/cli/main.py

@@ -1,23 +1,26 @@
 #!/usr/bin/python
 
-from .. import __version__
-from dbworkload.cli.dep import Param, EPILOG, ConnInfo
+import json
+import logging
+import os
+import platform
+import sys
 from enum import Enum
 from pathlib import Path
 from typing import Optional
 from urllib.parse import urlparse
+
+import pandas as pd
+import typer
+import yaml
+
 import dbworkload.cli.util
 import dbworkload.models.run
 import dbworkload.models.util
 import dbworkload.utils.common
-import json
-import logging
-import os
-import platform
-import sys
-import typer
-import yaml
-import pandas as pd
+from dbworkload.cli.dep import EPILOG, ConnInfo, Param
+
+from .. import __version__
 
 logger = logging.getLogger("dbworkload")
 
@@ -97,6 +100,12 @@ def run(
         help="Duration in seconds. Defaults to <ad infinitum>.",
         show_default=False,
     ),
+    max_rate: int = typer.Option(
+        None,
+        "--max-rate",
+        show_default=False,
+        help="Set the max-rate to have dbworkload manage concurrency. Defaults to None.",
+    ),
     conn_duration: int = typer.Option(
         None,
         "-k",
@@ -139,6 +148,11 @@ def run(
         "--schedule",
         help="schedule JSON string or filepath to the schedule file.",
     ),
+    histogram_bins: str = typer.Option(
+        "5,10,25,50,75,100,125,250,500,750,1000",
+        "--bins",
+        help="comma separated list of ints defining the histogram bins.",
+    ),
     log_level: LogLevel = Param.LogLevel,
 ):
     logger.setLevel(log_level.upper())
@@ -225,6 +239,7 @@ def run(
 
     args = load_args(args)
 
+    histogram_bins = histogram_bins.split(",")
     schedule = load_schedule(schedule)
 
     dbworkload.models.run.run(
@@ -237,11 +252,13 @@ def run(
         conn_info,
         duration,
         conn_duration,
+        max_rate,
         args,
         driver,
         quiet,
         save,
         schedule,
+        histogram_bins,
         log_level.upper(),
     )
 
@@ -289,13 +306,18 @@ def load_args(args: str):
 def load_schedule(schedule_path: str):
     if schedule_path:
         if os.path.exists(schedule_path):
-            return pd.read_csv(schedule_path, header=None).values.tolist()
+            df = pd.read_csv(schedule_path, dtype="Int64", comment="#").fillna(0)
+            # trasform ramp and duration columns from minutes to seconds
+            df[["ramp", "duration"]] = df[["ramp", "duration"]] * 60
+
+            return df.values.tolist()
         else:
             try:
                 return json.loads(schedule_path)
             except:
                 logger.error(f"couldn't decode {schedule_path} as JSON")
 
+
 def _version_callback(value: bool) -> None:
     if value:
         typer.echo(f"dbworkload : {__version__}")

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/dbworkload/cli/util.py

@@ -1,13 +1,15 @@
 #!/usr/bin/python
 
-from pathlib import Path
 from enum import Enum
+from pathlib import Path
 from typing import Optional
+
+import typer
+
 import dbworkload.models.run
 import dbworkload.models.util
 import dbworkload.utils.common
-from dbworkload.cli.dep import Param, EPILOG
-import typer
+from dbworkload.cli.dep import EPILOG, Param
 
 
 class Compression(str, Enum):

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/dbworkload/models/run.py

@@ -1,21 +1,23 @@
 #!/usr/bin/python
 
-from contextlib import contextmanager
-from dbworkload.cli.dep import ConnInfo
-import dbworkload.utils.common
+import errno
 import logging
-import logging.handlers
 import multiprocessing as mp
-import numpy as np
+import os
 import queue
 import random
 import signal
 import sys
-import sys
-import tabulate
-from threading import Thread
 import time
 import traceback
+from contextlib import contextmanager
+from threading import Thread
+
+import numpy as np
+import tabulate
+
+import dbworkload.utils.common
+from dbworkload.cli.dep import ConnInfo
 
 # from cassandra.cluster import Cluster, ExecutionProfile, EXEC_PROFILE_DEFAULT, Session
 # from cassandra.policies import (
@@ -30,6 +32,8 @@ DEFAULT_SLEEP = 3
 MAX_RETRIES = 3
 FREQUENCY = 10
 
+FIFO = "dbworkload.pipe"
+
 logger = logging.getLogger("dbworkload")
 
 
@@ -106,10 +110,10 @@ def signal_handler(sig, frame):
             sys.exit(1)
 
     logger.debug("Sent poison pill to all procs")
+    os.remove(FIFO)
 
 
 def cycle(iterable, backwards=False):
-
     global current_proc
 
     if not backwards:
@@ -121,7 +125,11 @@ def cycle(iterable, backwards=False):
         return v
 
 
-def ramp_up(
+# Launch or kill worker threads based on cc_change value.
+# workers are added or removed evenly across all supervisors.
+# If a ramp time is specified, threads creation or destruction
+# will be paced accordingly.
+def launch_or_kill_workers(
     queues: list,
     ramp_time: int,
     cc_change: int,
@@ -129,11 +137,10 @@ def ramp_up(
     iterations_per_thread,
     concurrency,
 ):
-
     if cc_change == 0:
         return
 
-    ramp_interval = ramp_time * 60 / abs(cc_change)
+    ramp_interval = ramp_time / abs(cc_change)
     global thread_id
 
     if cc_change > 0:
@@ -164,11 +171,13 @@ def run(
     conn_info: dict,
     duration: int,
     conn_duration: int,
+    max_rate: int,
     args: dict,
     driver: str,
     quiet: bool,
     save: bool,
     schedule: list,
+    histogram_bins: list,
     log_level: str,
 ):
     def gracefully_shutdown(by_keyinterrupt: bool = False):
@@ -188,7 +197,7 @@ def run(
                     logger.error("Timed out")
                     sys.exit(1)
 
-            for x in processes.values():
+            for x in supervisors.values():
                 if x.is_alive():
                     x.join()
 
@@ -321,19 +330,34 @@ def run(
 
     stats = dbworkload.utils.common.Stats(start_time)
 
-    prom = dbworkload.utils.common.Prom(prom_port)
+    prom = dbworkload.utils.common.Prom(prom_port, stats, histogram_bins)
 
     to_main_q = mp.Queue()
 
     global queues
-    global processes
-    processes = {}
+    global supervisors
+    supervisors = {}
     queues = {}
 
+    # start a separate thread for messages coming in via the pipe
+    # echo 5 > dbworkload.pipe # create 5 more connections
+    Thread(
+        target=listen_to_pipe,
+        daemon=True,
+        args=(
+            queues,
+            0,
+            procs,
+            None,
+            concurrency,
+        ),
+    ).start()
+
+    # launch supervisors in a dedicated OS process
     for x in range(procs):
         queues[x] = mp.Queue()
-        processes[x] = mp.Process(
-            target=proc,
+        supervisors[x] = mp.Process(
+            target=supervisor,
             args=(
                 to_main_q,
                 queues[x],
@@ -348,7 +372,7 @@ def run(
             ),
             daemon=True,
         )
-        processes[x].start()
+        supervisors[x].start()
 
     # report time happens 2 seconds after the stats are received.
     # we add this buffer to make sure we get all the stats reports
@@ -365,6 +389,7 @@ def run(
     current_proc = -1
     current_cc = 0
     thread_id = 0
+    pause_for_ramp_time = 0
 
     iterations_per_thread = None
     if iterations:
@@ -378,42 +403,67 @@ def run(
                 f"You have requested {iterations} iterations on {concurrency} threads. {iterations} modulo {concurrency} = {iterations%concurrency} iterations will not be executed."
             )
 
+    # if no schedule was passed, create a schedule with just 1 line
     if schedule is None:
-        schedule = [[concurrency, ramp / 60, duration / 60 if duration else duration]]
+        schedule = [(concurrency, max_rate, ramp, duration)]
 
+    # loop through all lines in the schedule
     for i, s in enumerate(schedule):
-
-        cc, ramp_time, dur = s
+        cc, max_rate, ramp_time, dur = s
 
         # sanitize
         if dur and ramp_time > dur:
             ramp_time = dur
 
-        logger.debug(
-            f"Starting schedule {i+1}/{len(schedule)}: cc = {cc}, ramp = {ramp_time}, dur = {dur}"
+        logger.info(
+            f"Starting schedule {i+1}/{len(schedule)}: cc={cc}, max_rate={max_rate}, ramp={ramp_time}, dur={dur}"
         )
 
-        if dur:
-            end_schedule_time = time.time() + dur * 60
-        else:
-            end_schedule_time = float("inf")
+        # always make sure that a duration is specified, even if none was passed
+        # in which case it defaults to infinite
+        end_schedule_time = time.time() + dur if dur else float("inf")
+
+        # if max_rate was set instead of concurrency
+        # and current_cc = 0,
+        # start the workload with 1 thread so that dbworkload
+        # has stats to measure on for adding/removing threads
+        # as part of the calculations for maintaining
+        # the desired max_rate
+        if current_cc == 0 and max_rate:
+            Thread(
+                target=launch_or_kill_workers,
+                daemon=True,
+                args=(
+                    queues,
+                    ramp_time,
+                    1,
+                    procs,
+                    iterations_per_thread,
+                    concurrency,
+                ),
+            ).start()
+
+            current_cc = 1
+
+        if not max_rate:
+            Thread(
+                target=launch_or_kill_workers,
+                daemon=True,
+                args=(
+                    queues,
+                    ramp_time,
+                    cc - current_cc,
+                    procs,
+                    iterations_per_thread,
+                    concurrency,
+                ),
+            ).start()
 
-        Thread(
-            target=ramp_up,
-            daemon=True,
-            args=(
-                queues,
-                ramp_time,
-                cc - current_cc,
-                procs,
-                iterations_per_thread,
-                concurrency,
-            ),
-        ).start()
+            current_cc = cc
 
-        current_cc = cc
         returned_threads = 0
 
+        # loop for the entire duration of the schedule's current line
         while time.time() < end_schedule_time:
             try:
                 # read from the queue for stats or completion messages
@@ -459,6 +509,55 @@ def run(
 
                 report = stats.calculate_stats(active_connections, endtime)
 
+                # if max_rate is specified, try to stick to it.
+                # to calculate how to get to the max rate, we need a non-empty report
+                if max_rate and report:
+                    current_rate = report[0][6]  # __cycle__ period_ops/s
+
+                    # approximate how many threads are needed to get
+                    # to the desired max_rate given the current QPS rate
+                    # and current threads count
+                    extrapolated_cc = int(max_rate / (current_rate / current_cc))
+
+                    # adjust the thread count if there is a difference
+                    # between the current thread count and the calculated
+                    # thread count, but not if there is one such operation already
+                    # running, that is, not if there's an operation that is slow due
+                    # to a long ramp_time.
+                    if (
+                        extrapolated_cc - current_cc
+                        and time.time() >= pause_for_ramp_time
+                    ):
+                        Thread(
+                            target=launch_or_kill_workers,
+                            daemon=True,
+                            args=(
+                                queues,
+                                ramp_time,
+                                extrapolated_cc - current_cc,
+                                procs,
+                                iterations_per_thread,
+                                concurrency,
+                            ),
+                        ).start()
+
+                        # make sure we will not add/remove threads while the newly
+                        # created thread is still working
+                        pause_for_ramp_time = time.time() + ramp_time + 2 * FREQUENCY
+
+                        logger.warning(
+                            f"Calculating max_rate: desired max_rate: {max_rate}, "
+                            f"current_rate: {report[0][6]}, current_cc = {current_cc}, "
+                            f"extrapolated_cc = {extrapolated_cc}, "
+                            f"difference: {extrapolated_cc-current_cc}"
+                        )
+                        current_cc = extrapolated_cc
+
+                        # ramp_time is only considered for reaching the desired max_rate.
+                        # For adjustments over time, we want the changes to happen immediately
+                        # and not smoothed out over the initial ramp_time value
+                        ramp_time = 0
+
                 centroids = stats.get_centroids()
 
                 stats.new_window(endtime)
@@ -486,7 +585,15 @@ def run(
     gracefully_shutdown()
 
 
-def proc(
+# a supervisor runs in a separate process.
+# The idea is to create as many supervisors as vCPUs.
+# The sole role of the supervisor is to listen for instructions
+# from the MainProcess.
+# Instructions are:
+#   - Create a new worker.
+#   - Destroy a worker.
+#   - Destroy all workers and return.
+def supervisor(
     to_main_q: mp.Queue,
     from_main_q: mp.Queue,
     log_level: str,
@@ -498,7 +605,6 @@ def proc(
     offset: int,
     id: int,
 ):
-
     def gracefully_return(msg):
         # wait for Threads to return before
         # letting the Process MainThread return
@@ -518,48 +624,42 @@ def proc(
         return
 
     logger.setLevel(log_level)
-
     logger.debug(f"PROC-{id} started")
 
     threads: list[Thread] = []
-
     from_proc_q = mp.Queue()
 
     # capture KeyboardInterrupt and do nothing
     signal.signal(signal.SIGINT, signal.SIG_IGN)
 
     while True:
-        try:
-            msg = from_main_q.get(block=True)
-
-            if msg == "proc_end":
-                logger.debug(f"PROC-{id} terminating...")
-                gracefully_return("proc_returned")
-                return
-            elif msg == "kill_one":
-                from_proc_q.put("poison_pill")
-            elif isinstance(msg, tuple):
-                t = Thread(
-                    target=worker,
-                    daemon=True,
-                    args=(
-                        to_main_q,
-                        from_proc_q,
-                        log_level,
-                        conn_info,
-                        driver,
-                        workload,
-                        args,
-                        conn_duration,
-                        offset,
-                        *msg,
-                    ),
-                )
-                t.start()
-                threads.append(t)
-
-        except queue.Empty:
-            pass
+        msg = from_main_q.get(block=True)
+
+        if msg == "proc_end":
+            logger.debug(f"PROC-{id} terminating...")
+            gracefully_return("proc_returned")
+            return
+        elif msg == "kill_one":
+            from_proc_q.put("poison_pill")
+        elif isinstance(msg, tuple):
+            t = Thread(
+                target=worker,
+                daemon=True,
+                args=(
+                    to_main_q,
+                    from_proc_q,
+                    log_level,
+                    conn_info,
+                    driver,
+                    workload,
+                    args,
+                    conn_duration,
+                    offset,
+                    *msg,
+                ),
+            )
+            t.start()
+            threads.append(t)
 
 
 def worker(
@@ -576,7 +676,6 @@ def worker(
     iterations: int = 0,
     concurrency: int = 0,
 ):
-
     def gracefully_return(msg):
         # send notification to MainThread
         to_main_q.put(msg)
@@ -732,6 +831,38 @@ def worker(
                 return
 
 
+def listen_to_pipe(queues, ramp_time, procs, iterations_per_thread, concurrency):
+    # https://stackoverflow.com/questions/39089776/python-read-named-pipe
+
+    try:
+        os.mkfifo(FIFO)
+    except OSError as oe:
+        if oe.errno != errno.EEXIST:
+            raise
+
+    while True:
+        with open(FIFO) as fifo:
+            for line in fifo:
+                try:
+                    t = int(line)
+                except:
+                    continue
+
+                logger.info(f"{'Adding' if t > 0 else 'Removing' } {abs(t)} threads.")
+                Thread(
+                    target=launch_or_kill_workers,
+                    daemon=True,
+                    args=(
+                        queues,
+                        ramp_time,
+                        t,
+                        procs,
+                        iterations_per_thread,
+                        concurrency,
+                    ),
+                ).start()
+
+
 def log_and_sleep(e: Exception):
     logger.error(f"error_type={e.__class__.__name__}, msg={e}")
     logger.info("Sleeping for %s seconds" % (DEFAULT_SLEEP))

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/dbworkload/models/util.py

@@ -1,28 +1,29 @@
 #!/usr/bin/python
 
-from io import TextIOWrapper
-from jinja2 import Environment, PackageLoader
-from pathlib import PosixPath
-from plotly.subplots import make_subplots
-from pytdigest import TDigest
 import datetime as dt
-import dbworkload
-import dbworkload.utils.common
-import dbworkload.utils.simplefaker
 import gzip
 import itertools
 import logging
-import numpy as np
 import os
+import shutil
+import sys
+from io import TextIOWrapper
+from pathlib import PosixPath
+
+import numpy as np
 import pandas as pd
 import plotext as plt
 import plotly.graph_objects as go
 import plotly.io as pio
-import shutil
 import sqlparse
-import sys
 import yaml
+from jinja2 import Environment, PackageLoader
+from plotly.subplots import make_subplots
+from pytdigest import TDigest
 
+import dbworkload
+import dbworkload.utils.common
+import dbworkload.utils.simplefaker
 
 logger = logging.getLogger("dbworkload")
 logger.setLevel(logging.INFO)
@@ -54,7 +55,9 @@ def util_csv(
     if os.path.isdir(output_dir):
         os.rename(
             output_dir,
-            str(output_dir) + "." + dt.datetime.now(dt.timezone.utc).strftime("%Y%m%d-%H%M%S"),
+            str(output_dir)
+            + "."
+            + dt.datetime.now(dt.timezone.utc).strftime("%Y%m%d-%H%M%S"),
         )
 
     # create new directory
@@ -102,7 +105,12 @@ def util_yaml(input: PosixPath, output: PosixPath):
 
     # backup the current file as to not override
     if os.path.exists(output):
-        os.rename(output, str(output) + "." + dt.datetime.now(dt.timezone.utc).strftime("%Y%m%d-%H%M%S"))
+        os.rename(
+            output,
+            str(output)
+            + "."
+            + dt.datetime.now(dt.timezone.utc).strftime("%Y%m%d-%H%M%S"),
+        )
 
     # create new file
     with open(output, "w") as f:

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/dbworkload/utils/common.py

@@ -2,14 +2,17 @@
 
 import importlib
 import logging
-import numpy as np
 import os
 import random
 import sys
 import time
 import urllib.parse
-import yaml
+
+import numpy as np
 import prometheus_client as prom
+import yaml
+from prometheus_client.core import REGISTRY, HistogramMetricFamily
+from prometheus_client.registry import Collector
 from pytdigest import TDigest
 
 RESERVED_WORDS = [
@@ -45,57 +48,8 @@ NOT_NULL_MAX = 40
 
 logger = logging.getLogger("dbworkload")
 
-
-class Prom:
-    def __init__(self, prom_port: int = 26260):
-        self.prom_latency: dict[str, list[prom.Gauge]] = {}
-
-        # don't stop just because prom server can't start
-        try:
-            prom.start_http_server(prom_port)
-        except OSError as e:
-            logger.warning(f"Cannot start prometheus server: {e}")
-
-        self.threads = prom.Gauge(
-            "threads", "count of connection threads to the database."
-        )
-
-    def publish(self, report: list):
-        for row in report:
-            id = row[1]
-
-            if id not in self.prom_latency:
-                self.prom_latency[id] = []
-                self.prom_latency[id].append(
-                    prom.Gauge(f"{id}__tot_ops", "total count of ops")
-                )
-                self.prom_latency[id].append(
-                    prom.Gauge(
-                        f"{id}__tot_ops_s", "derived value from tot_ops / elapsed"
-                    )
-                )
-                self.prom_latency[id].append(
-                    prom.Gauge(f"{id}__period_ops", "ops count for the recent window")
-                )
-                self.prom_latency[id].append(
-                    prom.Gauge(
-                        f"{id}__period_ops_s",
-                        "derived value from period_ops / window duration",
-                    )
-                )
-                self.prom_latency[id].append(prom.Gauge(f"{id}__mean_ms", "mean_ms"))
-                self.prom_latency[id].append(prom.Gauge(f"{id}__p50_ms", "p50_ms"))
-                self.prom_latency[id].append(prom.Gauge(f"{id}__p90_ms", "p90_ms"))
-                self.prom_latency[id].append(prom.Gauge(f"{id}__p95_ms", "p95_ms"))
-                self.prom_latency[id].append(prom.Gauge(f"{id}__p99_ms", "p99_ms"))
-                self.prom_latency[id].append(prom.Gauge(f"{id}__max_ms", "max_ms"))
-
-            for idx, v in enumerate(row[3:]):
-                self.prom_latency[id][idx].set(v)
-
-        # threads value is the same for all rows
-        if report:
-            self.threads.set(report[0][2])
+from prometheus_client.core import REGISTRY, HistogramMetricFamily
+from prometheus_client.registry import Collector
 
 
 class Stats:
@@ -216,6 +170,84 @@ class WorkerStats:
         ]
 
 
+class CustomHistogram(Collector):
+    def __init__(self, name: str, stats: Stats, bins: list):
+        self.name = name
+        self.stats = stats
+        self.bins = bins
+
+    def get_buckets(self, name):
+        td = self.stats.cumulative_counts.get(name)
+        if td is None:
+            return [["+Inf", 0]]
+
+        # create buckets from 10 ... 180
+        td_hist = [[x, int(td.cdf((int(x) + 1) / 1000) * td.weight)] for x in self.bins]
+        td_hist.append(["+Inf", td.weight])
+
+        return td.mean * 1000 * td.weight, td_hist
+
+    def collect(self):
+        sum_value, buckets = self.get_buckets(self.name)
+        yield HistogramMetricFamily(
+            f"{self.name}_latency_ms",
+            f"Latency in ms for {self.name}",
+            buckets,
+            sum_value,
+        )
+
+
+class Prom:
+    def __init__(self, prom_port: int = 26260, stats: Stats = None, bins: list = []):
+        self.prom_latency: dict[str, list[prom.Gauge]] = {}
+        self.stats = stats
+        self.bins = bins
+
+        # don't stop just because prom server can't start
+        try:
+            prom.start_http_server(prom_port)
+        except OSError as e:
+            logger.warning(f"Cannot start prometheus server: {e}")
+
+        self.threads = prom.Gauge(
+            "threads", "count of connection threads to the database."
+        )
+
+    def publish(self, report: list, td: dict = {}):
+        for row in report:
+            id = row[1]
+
+            if id not in self.prom_latency:
+                self.prom_latency[id] = []
+
+                REGISTRY.register(CustomHistogram(id, self.stats, self.bins))
+
+                self.prom_latency[id].append(
+                    prom.Gauge(f"{id}__tot_ops", "total count of ops")
+                )
+                self.prom_latency[id].append(
+                    prom.Gauge(
+                        f"{id}__tot_ops_s", "derived value from tot_ops / elapsed"
+                    )
+                )
+                self.prom_latency[id].append(
+                    prom.Gauge(f"{id}__period_ops", "ops count for the recent window")
+                )
+                self.prom_latency[id].append(
+                    prom.Gauge(
+                        f"{id}__period_ops_s",
+                        "derived value from period_ops / window duration",
+                    )
+                )
+
+            for idx, v in enumerate(row[3:6]):
+                self.prom_latency[id][idx].set(v)
+
+        # threads value is the same for all rows
+        if report:
+            self.threads.set(report[0][2])
+
+
 def get_driver_from_scheme(scheme: str):
     return {
         "postgres": "postgres",
@@ -654,23 +686,6 @@ def ddl_to_yaml(ddl: str):
             elif within_brackets > 0 and i == ",":
                 col_def += ":"
 
-        # process the content within parenthesis in the
-        # CREATE TABLE stmt char by char to distinguish
-        # the comma for separating columns vs the comma
-        # included in single quote strings such as those in DEFAULT
-        # eg: mycol STRING NULL DEFAULT 'corporate, inc'
-        within_quote = False
-        col_def_str = col_def
-        col_def = ""
-        for i in col_def_str:
-            if i == "'":
-                within_quote = not within_quote
-                continue
-            if within_quote:
-                continue
-            else:
-                col_def += i
-
         col_def = [x.strip().lower() for x in col_def.split(",")]
 
         ll = []

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/dbworkload/utils/simplefaker.py

@@ -1,12 +1,14 @@
+import builtins
 import csv
 import datetime as dt
 import logging
 import multiprocessing as mp
 import os
-import pandas as pd
-import uuid
 import random
-import builtins
+import uuid
+
+import pandas as pd
+
 from .common import import_class_at_runtime
 
 logger = logging.getLogger("dbworkload")

{dbworkload-0.7.0a1 → dbworkload-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dbworkload"
-version = "0.7.0a1"
+version = "0.8.2"
 description = "Workload framework"
 authors = ["Fabio Ghirardello"]
 license = "GPLv3+"