Public Member Functions
def	__init__ (self, count)

def	slow_multiple_conns_list (self)

def	slow_multiple_conns_dict (self)

def	insert_iterative_single_conn_list (self)

def	insert_iterative_single_conn_dict (self)

def	insert_executemany_dict (self)

def	insert_executemany_list (self)

def	fast_insert_execute_values_dict (self)

def	fast_insert_execute_values_list (self)

def	insert_execute_batch_dict (self)

def	insert_execute_batch_list (self)

def	fast_insert_many_mogrify (self)

def	fast_insert_unnest (self)

def	run (self)

Public Attributes
	data

	count

Detailed Description

Definition at line 218 of file ody_migr_benchmarks.py.

Member Function Documentation

◆ fast_insert_execute_values_dict()

def ody_migr_benchmarks.BulkInsertionTester.fast_insert_execute_values_dict ( self )

    One connection, one query - multiple values insertions.
    Uses psycopg2.extras.execute_values

Definition at line 311 of file ody_migr_benchmarks.py.

     def fast_insert_execute_values_dict(self):
         '''
             One connection, one query - multiple values insertions.
             Uses psycopg2.extras.execute_values
         '''
         (insert_query,
          template) = pg_handler.pg_prepare_insert_script_execute_values_dict(
             TEST_TABLE_NAME_STR, fixture_columns)
 
         with connect() as connection:
             with connection.cursor() as cursor:
                 execute_values(
                     cursor,
                     insert_query.as_string(connection),
                     self.data,
                     template=template.as_string(connection),
                     page_size=self.count
                 )
 

◆ fast_insert_execute_values_list()

def ody_migr_benchmarks.BulkInsertionTester.fast_insert_execute_values_list ( self )

    One connection, one query - multiple values insertions.
    Uses psycopg2.extras.execute_values

Definition at line 330 of file ody_migr_benchmarks.py.

     def fast_insert_execute_values_list(self):
         '''
             One connection, one query - multiple values insertions.
             Uses psycopg2.extras.execute_values
         '''
         values = []
         for row in self.data:
             # still linear, done to match the order of cols and values
             row_vals = [row[col] for col in fixture_columns]
             values.append(row_vals)
 
         (insert_query,
          template) = pg_handler.pg_prepare_insert_script_execute_values_list(
             TEST_TABLE_NAME_STR, fixture_columns)
 
         with connect() as connection:
             with connection.cursor() as cursor:
                 execute_values(cursor,
                                insert_query.as_string(connection),
                                values,
                                template=template.as_string(connection),
                                page_size=self.count
                                )
 

◆ fast_insert_many_mogrify()

def ody_migr_benchmarks.BulkInsertionTester.fast_insert_many_mogrify ( self )

One connection, one query - multiple values insertions.
Uses cursor.mogrify to validate scripts

Definition at line 394 of file ody_migr_benchmarks.py.

     def fast_insert_many_mogrify(self):
         '''
         One connection, one query - multiple values insertions.
         Uses cursor.mogrify to validate scripts
 
         '''
         values = []
         for row in self.data:
             # still linear, done to match the order of cols and values
             row_vals = [row[col] for col in fixture_columns]
             values.append(row_vals)
 
         with connect() as connection:
             with connection.cursor() as cursor:
                 insert_query = pg_prepare_insert_script_cursor_mogrify(
                     TEST_TABLE_NAME_STR, fixture_columns, cursor, values)
                 cursor.execute(insert_query)
 

◆ fast_insert_unnest()

def ody_migr_benchmarks.BulkInsertionTester.fast_insert_unnest ( self )

One connection, one query - multiple values insertions.
Insertion script incorporate unnest + dictionary keys.

`values` can also be passed as:
    first_name = [r['first_name'] for r in self.data]
    last_name = [r['last_name'] for r in self.data]
    email = [r['email'] for r in self.data]
    gender = [r['gender'] for r in self.data]
    ip_address = [r['ip_address'] for r in self.data]
    ssn = [r['ssn'] for r in self.data]
    company_name = [r['company_name'] for r in self.data]
    race = [r['race'] for r in self.data]
    department = [r['department'] for r in self.data]
    values = locals()

Definition at line 412 of file ody_migr_benchmarks.py.

     def fast_insert_unnest(self):
         """
         One connection, one query - multiple values insertions.
         Insertion script incorporate unnest + dictionary keys.
 
         `values` can also be passed as:
             first_name = [r['first_name'] for r in self.data]
             last_name = [r['last_name'] for r in self.data]
             email = [r['email'] for r in self.data]
             gender = [r['gender'] for r in self.data]
             ip_address = [r['ip_address'] for r in self.data]
             ssn = [r['ssn'] for r in self.data]
             company_name = [r['company_name'] for r in self.data]
             race = [r['race'] for r in self.data]
             department = [r['department'] for r in self.data]
             values = locals()
         """
         insert_sql = pg_handler.pg_prepare_insert_script_unnest(
             TEST_TABLE_NAME_STR, fixture_columns)
 
         values = {}
         for col in fixture_columns:
             values[col] = [r[col] for r in self.data]
 
         with connect() as connection:
             with connection.cursor() as cursor:
                 cursor.execute(insert_sql, values)
 

◆ insert_execute_batch_dict()

def ody_migr_benchmarks.BulkInsertionTester.insert_execute_batch_dict ( self )

    One connection, one query - multiple values insertions.
    Uses psycopg2.extras.execute_batch() - list of dict

Definition at line 354 of file ody_migr_benchmarks.py.

     def insert_execute_batch_dict(self):
         '''
             One connection, one query - multiple values insertions.
             Uses psycopg2.extras.execute_batch() - list of dict
         '''
         # query similar to executemany()
         insert_query = pg_prepare_insert_script_executemany_dict(
             TEST_TABLE_NAME_STR, fixture_columns)
 
         with connect() as connection:
             with connection.cursor() as cursor:
                 execute_batch(cursor,
                               insert_query,
                               self.data,
                               page_size=self.count
                               )
 

◆ insert_execute_batch_list()

def ody_migr_benchmarks.BulkInsertionTester.insert_execute_batch_list ( self )

     One connection, one query - multiple values insertions.
    Uses psycopg2.extras.execute_batch() - list of list

Definition at line 371 of file ody_migr_benchmarks.py.

     def insert_execute_batch_list(self):
         '''
              One connection, one query - multiple values insertions.
             Uses psycopg2.extras.execute_batch() - list of list
 
         '''
         values = []
         for row in self.data:
             # still linear, done to match the order of cols and values
             row_vals = [row[col] for col in fixture_columns]
             values.append(row_vals)
 
         with connect() as connection:
             with connection.cursor() as cursor:
                 # query similar to executemany()
                 insert_query = pg_prepare_insert_script_executemany_list(
                     TEST_TABLE_NAME_STR, fixture_columns)
                 execute_batch(cursor,
                               insert_query,
                               values,
                               page_size=self.count
                               )
 

◆ insert_executemany_dict()

def ody_migr_benchmarks.BulkInsertionTester.insert_executemany_dict ( self )

    One connection multiple queries.
    Uses cursor.executemany() - list of values (dictionary)

Definition at line 281 of file ody_migr_benchmarks.py.

     def insert_executemany_dict(self):
         '''
             One connection multiple queries.
             Uses cursor.executemany() - list of values (dictionary)
 
         '''
         with connect() as connection:
             with connection.cursor() as cursor:
                 executemany_script = pg_prepare_insert_script_executemany_dict(
                     TEST_TABLE_NAME_STR, fixture_columns)
                 cursor.executemany(executemany_script, self.data)
 

◆ insert_executemany_list()

def ody_migr_benchmarks.BulkInsertionTester.insert_executemany_list ( self )

    One connection multiple queries.
    Uses cursor.executemany() - list of values (list)

Definition at line 293 of file ody_migr_benchmarks.py.

     def insert_executemany_list(self):
         '''
             One connection multiple queries.
             Uses cursor.executemany() - list of values (list)
         '''
         values = []
         for row in self.data:
             # still linear, done to match the order of cols and values
             row_vals = [row[col] for col in fixture_columns]
             values.append(row_vals)
 
         with connect() as connection:
             with connection.cursor() as cursor:
                 executemany_script = pg_prepare_insert_script_executemany_list(
                     TEST_TABLE_NAME_STR, fixture_columns)
 
                 cursor.executemany(executemany_script, values)
 

◆ insert_iterative_single_conn_dict()

def ody_migr_benchmarks.BulkInsertionTester.insert_iterative_single_conn_dict ( self )

    One connection multiple queries (iterative).
    Insertion script incorporate dictionary values

Definition at line 268 of file ody_migr_benchmarks.py.

     def insert_iterative_single_conn_dict(self):
         '''
             One connection multiple queries (iterative).
             Insertion script incorporate dictionary values
         '''
         with connect() as connection:
             with connection.cursor() as cursor:
                 for row in self.data:
                     # row is a dictionary
                     single_insert = pg_handler.pg_prepare_insert_single_dict(
                         TEST_TABLE_NAME_STR, fixture_columns)
                     cursor.execute(single_insert, row)
 

◆ insert_iterative_single_conn_list()

def ody_migr_benchmarks.BulkInsertionTester.insert_iterative_single_conn_list ( self )

    One connection multiple queries (iterative).
    Insertion script incorporate list/tuple values

Definition at line 254 of file ody_migr_benchmarks.py.

     def insert_iterative_single_conn_list(self):
         '''
             One connection multiple queries (iterative).
             Insertion script incorporate list/tuple values
         '''
         with connect() as connection:
             with connection.cursor() as cursor:
                 for row in self.data:
                     cols = list(row.keys())
                     vals = list(row.values())
                     insert_script = pg_handler.pg_prepare_insert_single_list(
                         TEST_TABLE_NAME_STR, cols)
                     cursor.execute(insert_script, vals)
 

◆ slow_multiple_conns_dict()

def ody_migr_benchmarks.BulkInsertionTester.slow_multiple_conns_dict ( self )

    Creates a new connection for each insertion
    Insertion script incorporate dictionary values

Definition at line 243 of file ody_migr_benchmarks.py.

     def slow_multiple_conns_dict(self):
         '''
             Creates a new connection for each insertion
             Insertion script incorporate dictionary values
         '''
         for row in self.data:
             # row is a dictionary of columns and values
             single_insert = pg_handler.pg_prepare_insert_single_dict(
                 TEST_TABLE_NAME_STR, fixture_columns)
             execute(single_insert, row)
 

◆ slow_multiple_conns_list()

def ody_migr_benchmarks.BulkInsertionTester.slow_multiple_conns_list ( self )

Creates a new connection for each insertion

Definition at line 233 of file ody_migr_benchmarks.py.

     def slow_multiple_conns_list(self):
         '''Creates a new connection for each insertion'''
         for row in self.data:
             cols = list(row.keys())
             vals = list(row.values())
             # get insertion script to insert values in list/tuple form
             insert_script = pg_handler.pg_prepare_insert_single_list(
                 TEST_TABLE_NAME_STR, cols)
             execute(insert_script, vals)
 

The documentation for this class was generated from the following file:

app/tools/bin/ody_migr_benchmarks.py

Public Member Functions

Public Attributes