tryton-db-migration/reports/updateChanges/stock_lot.md

# modul stock_lot


## Tabelle product_template

### 5.4

- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*table.update([table.lot_required], [value], where=table.id == template_id)`
  - code:
    '(connection.cursor()).execute(*table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id))'
- **after_super** `update`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table`
  - files:
    - `product.py`
  - args: `[table.lot_required], [value]`
  - kwargs:
    - where: `table.id == template_id`
  - code:
    'table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id)'


### 5.8

- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*table.update([table.lot_required], [value], where=table.id == template_id)`
  - code:
    '(connection.cursor()).execute(*table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id))'
- **after_super** `update`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table`
  - files:
    - `product.py`
  - args: `[table.lot_required], [value]`
  - kwargs:
    - where: `table.id == template_id`
  - code:
    'table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id)'


### 6.2

- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*table.update([table.lot_required], [value], where=table.id == template_id)`
  - code:
    '(connection.cursor()).execute(*table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id))'
- **after_super** `update`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table`
  - files:
    - `product.py`
  - args: `[table.lot_required], [value]`
  - kwargs:
    - where: `table.id == template_id`
  - code:
    'table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id)'


### 6.6

- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*table.update([table.lot_required], [value], where=table.id == template_id)`
  - code:
    '(connection.cursor()).execute(*table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id))'
- **after_super** `update`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table`
  - files:
    - `product.py`
  - args: `[table.lot_required], [value]`
  - kwargs:
    - where: `table.id == template_id`
  - code:
    'table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id)'


### 7.0

- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*table.update([table.lot_required], [value], where=table.id == template_id)`
  - code:
    '(connection.cursor()).execute(*table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id))'
- **after_super** `update`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table`
  - files:
    - `product.py`
  - args: `[table.lot_required], [value]`
  - kwargs:
    - where: `table.id == template_id`
  - code:
    'table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id)'


### 7.4

- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*table.update([table.lot_required], [value], where=table.id == template_id)`
  - code:
    '(connection.cursor()).execute(*table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id))'
- **after_super** `update`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table`
  - files:
    - `product.py`
  - args: `[table.lot_required], [value]`
  - kwargs:
    - where: `table.id == template_id`
  - code:
    'table.update(
                        [table.lot_required], [(cls.lot_required.sql_format([t for t, in cursor]))],
                        where=table.id == template_id)'


## Tabelle unknown

### 5.0

- **before_super** `get`
  - object: `backend`
  - files:
    - `party.py`
  - args: `'TableHandler'`
  - code:
    'backend.get('(backend.get('TableHandler'))')'
- **before_super** `table_exist`
  - object: `TableHandler`
  - files:
    - `party.py`
  - args: `cls._table`
  - code:
    '(backend.get('TableHandler')).table_exist(cls._table)'
- **before_super** `column_exist`
  - condition: `exist`
  - object: `table`
  - files:
    - `party.py`
  - args: `'company'`
  - code:
    'table.column_exist('company')'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.configuration', cls._configuration_value_field, cls, cls._configuration_value_field`
  - kwargs:
    - fields: `['company']`
  - code:
    'migrate_property(
                'party.configuration', cls._configuration_value_field,
                cls, cls._configuration_value_field, fields=['company'])'
- **after_super** `_migrate_property`
  - condition: `not exist`
  - object: `super(PartyLang, cls)`
  - files:
    - `party.py`
  - args: `field_names, value_names, fields`
  - code:
    'super(PartyLang, cls)._migrate_property(
            field_names, value_names, fields)'
- **after_super** `super`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `PartyLang, cls`
  - code:
    'super(PartyLang, cls)'
- **after_super** `Transaction`
  - files:
    - `action.py`
  - code:
    'Transaction()'
- **after_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `action.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `action.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `Transaction`
  - files:
    - `action.py`
  - code:
    'Transaction()'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `Concat(attachment.digest, '-'), attachment.collision`
  - code:
    'Concat(Concat(attachment.digest, '-'),
                            attachment.collision)'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `attachment.digest, '-'`
  - code:
    'Concat(attachment.digest, '-')'
- **before_super** `Pool`
  - files:
    - `module.py`
  - code:
    'Pool()'
- **before_super** `table_rename`
  - condition: `TableHandler.table_exist(old_table)`
  - object: `TableHandler`
  - files:
    - `module.py`
  - args: `old_table, cls._table`
  - code:
    '(backend.get('TableHandler')).table_rename(old_table, cls._table)'
- **after_super** `in_`
  - object: `model_data_sql_table.fs_id`
  - files:
    - `module.py`
  - args: `button_fs_ids`
  - code:
    'model_data_sql_table.fs_id.in_(button_fs_ids)'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `translation.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `timedelta`
  - condition: `table.column_exist('minimum_delay')`
  - object: `datetime`
  - files:
    - `trigger.py`
  - kwargs:
    - hours: `delay`
  - code:
    'datetime.timedelta(hours=(datetime.timedelta(hours=delay)))'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `Coalesce(sql_table.street, ''), Concat('\n', Coalesce(sql_table.streetbis, ''))`
  - code:
    'Concat(
                Coalesce(sql_table.street, ''),
                Concat('\n', Coalesce(sql_table.streetbis, '')))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.street, ''`
  - code:
    'Coalesce(sql_table.street, '')'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `'\n', Coalesce(sql_table.streetbis, '')`
  - code:
    'Concat('\n', Coalesce(sql_table.streetbis, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.streetbis, ''`
  - code:
    'Coalesce(sql_table.streetbis, '')'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'party.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'party.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `execute`
  - condition: `party_h.column_exist('lang')`
  - object: `cursor`
  - files:
    - `party.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.insert(
                    [table.party, table.lang],
                    party.select(party.id, party.lang))))'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.party', field_names, cls, value_names`
  - kwargs:
    - parent: `'party'`
    - fields: `fields`
  - code:
    'migrate_property(
            'party.party', field_names, cls, value_names,
            parent='party', fields=fields)'
- **after_super** `cls`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - kwargs:
    - party: `party_id`
    - code: `code`
    - type: `type`
  - code:
    'cls(party=party_id, code=code, type=type)'
- **after_super** `save`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `cls`
  - files:
    - `party.py`
  - args: `identifiers`
  - code:
    'cls.save(identifiers)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'product.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'product.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `product.py`
  - args: `'product.template', field_names, cls, value_names`
  - kwargs:
    - parent: `'template'`
    - fields: `fields`
  - code:
    'migrate_property(
            'product.template', field_names, cls, value_names,
            parent='template', fields=fields)'
- **before_super** `table_exist`
  - object: `TableHandler`
  - files:
    - `product.py`
  - args: `ProductCostPrice._table`
  - code:
    '(backend.get('TableHandler')).table_exist(ProductCostPrice._table)'
- **after_super** `TableHandler`
  - condition: `not exist and cost_price_exist`
  - files:
    - `product.py`
  - args: `ProductCostPrice, module_name`
  - code:
    '(backend.get('TableHandler'))(ProductCostPrice, module_name)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `sql_table, c`
  - code:
    'Column(sql_table, c)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `cost_price, c`
  - code:
    'Column(cost_price, c)'
- **after_super** `select`
  - condition: `table.column_exist('template')`
  - object: `sql_table.join(product, condition=sql_table.template == product.template)`
  - files:
    - `product.py`
  - args: `*[Column(sql_table, c) for c in columns] + [product.id]`
  - kwargs:
    - where: `(sql_table.template != Null) & (sql_table.product == Null)`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        ).select(
                        *[Column(sql_table, c) for c in columns]
                        + [product.id],
                        where=(sql_table.template != Null)
                        & (sql_table.product == Null))'
- **after_super** `join`
  - condition: `table.column_exist('template')`
  - object: `sql_table`
  - files:
    - `product.py`
  - args: `product`
  - kwargs:
    - condition: `sql_table.template == product.template`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        )'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'production.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'production.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `production.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'sha1$', Concat(sqltable.password, Concat('$', Coalesce(sqltable.salt, '')))`
  - code:
    'Concat('sha1$', Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, ''))))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.password, Concat('$', Coalesce(sqltable.salt, ''))`
  - code:
    'Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, '')))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'$', Coalesce(sqltable.salt, '')`
  - code:
    'Concat('$', Coalesce(sqltable.salt, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.salt, ''`
  - code:
    'Coalesce(sqltable.salt, '')'


### 5.2

- **after_super** `get_cc_module`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - args: `*type.split('_', 1)`
  - code:
    'get_cc_module(*type.split('_', 1))'
- **after_super** `split`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `type`
  - files:
    - `party.py`
  - args: `'_', 1`
  - code:
    'type.split('_', 1)'


### 5.4

- **before_super** `get`
  - object: `backend`
  - files:
    - `party.py`
  - args: `'TableHandler'`
  - code:
    'backend.get('(backend.get('TableHandler'))')'
- **before_super** `table_exist`
  - object: `TableHandler`
  - files:
    - `party.py`
  - args: `cls._table`
  - code:
    '(backend.get('TableHandler')).table_exist(cls._table)'
- **before_super** `column_exist`
  - condition: `exist`
  - object: `table`
  - files:
    - `party.py`
  - args: `'company'`
  - code:
    'table.column_exist('company')'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.configuration', cls._configuration_value_field, cls, cls._configuration_value_field`
  - kwargs:
    - fields: `['company']`
  - code:
    'migrate_property(
                'party.configuration', cls._configuration_value_field,
                cls, cls._configuration_value_field, fields=['company'])'
- **after_super** `_migrate_property`
  - condition: `not exist`
  - object: `super(PartyLang, cls)`
  - files:
    - `party.py`
  - args: `field_names, value_names, fields`
  - code:
    'super(PartyLang, cls)._migrate_property(
            field_names, value_names, fields)'
- **after_super** `super`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `PartyLang, cls`
  - code:
    'super(PartyLang, cls)'
- **before_super** `Pool`
  - files:
    - `country.py`
  - code:
    'Pool()'
- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `country.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `Transaction`
  - files:
    - `country.py`
  - code:
    'Transaction()'
- **after_super** `Transaction`
  - files:
    - `action.py`
  - code:
    'Transaction()'
- **after_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `action.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `Concat(attachment.digest, '-'), attachment.collision`
  - code:
    'Concat(Concat(attachment.digest, '-'),
                            attachment.collision)'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `attachment.digest, '-'`
  - code:
    'Concat(attachment.digest, '-')'
- **before_super** `table_rename`
  - condition: `TableHandler.table_exist(old_table)`
  - object: `TableHandler`
  - files:
    - `module.py`
  - args: `old_table, cls._table`
  - code:
    '(backend.get('TableHandler')).table_rename(old_table, cls._table)'
- **after_super** `in_`
  - object: `model_data_sql_table.fs_id`
  - files:
    - `module.py`
  - args: `button_fs_ids`
  - code:
    'model_data_sql_table.fs_id.in_(button_fs_ids)'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `translation.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `timedelta`
  - condition: `table.column_exist('minimum_delay')`
  - object: `datetime`
  - files:
    - `trigger.py`
  - kwargs:
    - hours: `delay`
  - code:
    'datetime.timedelta(hours=(datetime.timedelta(hours=delay)))'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `Coalesce(sql_table.street, ''), Concat('\n', Coalesce(sql_table.streetbis, ''))`
  - code:
    'Concat(
                Coalesce(sql_table.street, ''),
                Concat('\n', Coalesce(sql_table.streetbis, '')))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.street, ''`
  - code:
    'Coalesce(sql_table.street, '')'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `'\n', Coalesce(sql_table.streetbis, '')`
  - code:
    'Concat('\n', Coalesce(sql_table.streetbis, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.streetbis, ''`
  - code:
    'Coalesce(sql_table.streetbis, '')'
- **after_super** `execute`
  - condition: `table_h.column_exist('country')`
  - object: `cursor`
  - files:
    - `address.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.update(
                [table.language_code],
                language.select(
                    Substring(language.code, 0, 2),
                    where=language.id == table.language))))'
- **after_super** `Substring`
  - condition: `table_h.column_exist('language')`
  - files:
    - `address.py`
  - args: `language.code, 0, 2`
  - code:
    'Substring(language.code, 0, 2)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'party.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'party.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `execute`
  - condition: `party_h.column_exist('lang')`
  - object: `cursor`
  - files:
    - `party.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.insert(
                    [table.party, table.lang],
                    party.select(party.id, party.lang))))'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.party', field_names, cls, value_names`
  - kwargs:
    - parent: `'party'`
    - fields: `fields`
  - code:
    'migrate_property(
            'party.party', field_names, cls, value_names,
            parent='party', fields=fields)'
- **after_super** `cls`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - kwargs:
    - party: `party_id`
    - code: `code`
    - type: `type`
  - code:
    'cls(party=party_id, code=code, type=type)'
- **after_super** `save`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `cls`
  - files:
    - `party.py`
  - args: `identifiers`
  - code:
    'cls.save(identifiers)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'product.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'product.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `product.py`
  - args: `'product.template', field_names, cls, value_names`
  - kwargs:
    - parent: `'template'`
    - fields: `fields`
  - code:
    'migrate_property(
            'product.template', field_names, cls, value_names,
            parent='template', fields=fields)'
- **before_super** `table_exist`
  - object: `TableHandler`
  - files:
    - `product.py`
  - args: `ProductCostPrice._table`
  - code:
    '(backend.get('TableHandler')).table_exist(ProductCostPrice._table)'
- **after_super** `TableHandler`
  - condition: `not exist and cost_price_exist`
  - files:
    - `product.py`
  - args: `ProductCostPrice, module_name`
  - code:
    '(backend.get('TableHandler'))(ProductCostPrice, module_name)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `sql_table, c`
  - code:
    'Column(sql_table, c)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `cost_price, c`
  - code:
    'Column(cost_price, c)'
- **after_super** `select`
  - condition: `table.column_exist('template')`
  - object: `sql_table.join(product, condition=sql_table.template == product.template)`
  - files:
    - `product.py`
  - args: `*[Column(sql_table, c) for c in columns] + [product.id]`
  - kwargs:
    - where: `(sql_table.template != Null) & (sql_table.product == Null)`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        ).select(
                        *[Column(sql_table, c) for c in columns]
                        + [product.id],
                        where=(sql_table.template != Null)
                        & (sql_table.product == Null))'
- **after_super** `join`
  - condition: `table.column_exist('template')`
  - object: `sql_table`
  - files:
    - `product.py`
  - args: `product`
  - kwargs:
    - condition: `sql_table.template == product.template`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        )'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'production.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'production.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `production.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'sha1$', Concat(sqltable.password, Concat('$', Coalesce(sqltable.salt, '')))`
  - code:
    'Concat('sha1$', Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, ''))))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.password, Concat('$', Coalesce(sqltable.salt, ''))`
  - code:
    'Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, '')))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'$', Coalesce(sqltable.salt, '')`
  - code:
    'Concat('$', Coalesce(sqltable.salt, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.salt, ''`
  - code:
    'Coalesce(sqltable.salt, '')'
- **before_super** `cursor`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'product.template-stock.lot.type'`
  - kwargs:
    - default: `'product.template-stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))'
- **after_super** `replace`
  - object: `'product.template-stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''product.template-stock.lot.type' .replace('.', '_')'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'stock.lot.type'`
  - kwargs:
    - default: `'stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))'
- **after_super** `replace`
  - object: `'stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''stock.lot.type'.replace('.', '_')'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `template_lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'
- **after_super** `cursor`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor_select`
  - files:
    - `product.py`
  - args: `*template_lot_type.select(template_lot_type.template, distinct_on=template_lot_type.template)`
  - code:
    '(connection.cursor()).execute(*template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `template_lot_type.template`
  - kwargs:
    - distinct_on: `template_lot_type.template`
  - code:
    'template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template)'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id).select(lot_type.code, where=template_lot_type.template == template_id)`
  - code:
    '(connection.cursor()).execute(*template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id)`
  - files:
    - `product.py`
  - args: `lot_type.code`
  - kwargs:
    - where: `template_lot_type.template == template_id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id)'
- **after_super** `join`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `lot_type`
  - kwargs:
    - condition: `template_lot_type.type == lot_type.id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)'
- **after_super** `sql_format`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cls.lot_required`
  - files:
    - `product.py`
  - args: `[t for t, in cursor]`
  - code:
    'cls.lot_required.sql_format([t for t, in (connection.cursor())])'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'product.template-stock.lot.type', template_lot_type_table_name`
  - code:
    'table_h.drop_table('product.template-stock.lot.type',
                (config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'stock.lot.type', lot_type_table_name`
  - code:
    'table_h.drop_table('stock.lot.type', (config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'


### 5.6

- **after_super** `Pool`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - code:
    'Pool()'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `action_model, Concat('|', sql_table.action_function)`
  - code:
    'Concat((model.select(
                model.model, where=model.id == sql_table.action_model)), Concat(
                                '|', sql_table.action_function))'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `'|', sql_table.action_function`
  - code:
    'Concat(
                                '|', sql_table.action_function)'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `configuration.py`
  - args: `cls._table`
  - code:
    'backend.TableHandler.table_exist(cls._table)'
- **after_super** `get_cc_module`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - args: `*type.split('_', 1)`
  - code:
    'get_cc_module(*type.split('_', 1))'
- **after_super** `split`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `type`
  - files:
    - `party.py`
  - args: `'_', 1`
  - code:
    'type.split('_', 1)'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'code'`
  - code:
    'table_h.column_exist('code')'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'suffix_code'`
  - code:
    'table_h.column_exist('suffix_code')'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `product.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `product.py`
  - args: `ProductCostPrice._table`
  - code:
    'backend.TableHandler.table_exist(
            ProductCostPrice._table)'
- **after_super** `TableHandler`
  - condition: `not exist and cost_price_exist`
  - object: `backend`
  - files:
    - `product.py`
  - args: `ProductCostPrice, module_name`
  - code:
    'backend.TableHandler(
                ProductCostPrice, module_name)'


### 5.8

- **before_super** `column_exist`
  - condition: `exist`
  - object: `table`
  - files:
    - `party.py`
  - args: `'company'`
  - code:
    'table.column_exist('company')'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.configuration', cls._configuration_value_field, cls, cls._configuration_value_field`
  - kwargs:
    - fields: `['company']`
  - code:
    'migrate_property(
                'party.configuration', cls._configuration_value_field,
                cls, cls._configuration_value_field, fields=['company'])'
- **after_super** `_migrate_property`
  - condition: `not exist`
  - object: `super(PartyLang, cls)`
  - files:
    - `party.py`
  - args: `field_names, value_names, fields`
  - code:
    'super(PartyLang, cls)._migrate_property(
            field_names, value_names, fields)'
- **after_super** `super`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `PartyLang, cls`
  - code:
    'super(PartyLang, cls)'
- **before_super** `Pool`
  - files:
    - `country.py`
  - code:
    'Pool()'
- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `country.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `Transaction`
  - files:
    - `country.py`
  - code:
    'Transaction()'
- **after_super** `Transaction`
  - files:
    - `action.py`
  - code:
    'Transaction()'
- **after_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `action.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `Concat(attachment.digest, '-'), attachment.collision`
  - code:
    'Concat(Concat(attachment.digest, '-'),
                            attachment.collision)'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `attachment.digest, '-'`
  - code:
    'Concat(attachment.digest, '-')'
- **after_super** `in_`
  - object: `model_data_sql_table.fs_id`
  - files:
    - `module.py`
  - args: `button_fs_ids`
  - code:
    'model_data_sql_table.fs_id.in_(button_fs_ids)'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `translation.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `timedelta`
  - condition: `table.column_exist('minimum_delay')`
  - object: `datetime`
  - files:
    - `trigger.py`
  - kwargs:
    - hours: `delay`
  - code:
    'datetime.timedelta(hours=(datetime.timedelta(hours=delay)))'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `Coalesce(sql_table.street, ''), Concat('\n', Coalesce(sql_table.streetbis, ''))`
  - code:
    'Concat(
                Coalesce(sql_table.street, ''),
                Concat('\n', Coalesce(sql_table.streetbis, '')))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.street, ''`
  - code:
    'Coalesce(sql_table.street, '')'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `'\n', Coalesce(sql_table.streetbis, '')`
  - code:
    'Concat('\n', Coalesce(sql_table.streetbis, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.streetbis, ''`
  - code:
    'Coalesce(sql_table.streetbis, '')'
- **after_super** `execute`
  - condition: `table_h.column_exist('country')`
  - object: `cursor`
  - files:
    - `address.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.update(
                [table.language_code],
                language.select(
                    Substring(language.code, 0, 2),
                    where=language.id == table.language))))'
- **after_super** `Substring`
  - condition: `table_h.column_exist('language')`
  - files:
    - `address.py`
  - args: `language.code, 0, 2`
  - code:
    'Substring(language.code, 0, 2)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'party.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'party.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `execute`
  - condition: `party_h.column_exist('lang')`
  - object: `cursor`
  - files:
    - `party.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.insert(
                    [table.party, table.lang],
                    party.select(party.id, party.lang))))'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.party', field_names, cls, value_names`
  - kwargs:
    - parent: `'party'`
    - fields: `fields`
  - code:
    'migrate_property(
            'party.party', field_names, cls, value_names,
            parent='party', fields=fields)'
- **after_super** `cls`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - kwargs:
    - party: `party_id`
    - code: `code`
    - type: `type`
  - code:
    'cls(party=party_id, code=code, type=type)'
- **after_super** `save`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `cls`
  - files:
    - `party.py`
  - args: `identifiers`
  - code:
    'cls.save(identifiers)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'product.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'product.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `product.py`
  - args: `'product.template', field_names, cls, value_names`
  - kwargs:
    - parent: `'template'`
    - fields: `fields`
  - code:
    'migrate_property(
            'product.template', field_names, cls, value_names,
            parent='template', fields=fields)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `sql_table, c`
  - code:
    'Column(sql_table, c)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `cost_price, c`
  - code:
    'Column(cost_price, c)'
- **after_super** `select`
  - condition: `table.column_exist('template')`
  - object: `sql_table.join(product, condition=sql_table.template == product.template)`
  - files:
    - `product.py`
  - args: `*[Column(sql_table, c) for c in columns] + [product.id]`
  - kwargs:
    - where: `(sql_table.template != Null) & (sql_table.product == Null)`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        ).select(
                        *[Column(sql_table, c) for c in columns]
                        + [product.id],
                        where=(sql_table.template != Null)
                        & (sql_table.product == Null))'
- **after_super** `join`
  - condition: `table.column_exist('template')`
  - object: `sql_table`
  - files:
    - `product.py`
  - args: `product`
  - kwargs:
    - condition: `sql_table.template == product.template`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        )'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'production.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'production.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'sha1$', Concat(sqltable.password, Concat('$', Coalesce(sqltable.salt, '')))`
  - code:
    'Concat('sha1$', Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, ''))))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.password, Concat('$', Coalesce(sqltable.salt, ''))`
  - code:
    'Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, '')))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'$', Coalesce(sqltable.salt, '')`
  - code:
    'Concat('$', Coalesce(sqltable.salt, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.salt, ''`
  - code:
    'Coalesce(sqltable.salt, '')'
- **before_super** `cursor`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'product.template-stock.lot.type'`
  - kwargs:
    - default: `'product.template-stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))'
- **after_super** `replace`
  - object: `'product.template-stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''product.template-stock.lot.type' .replace('.', '_')'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'stock.lot.type'`
  - kwargs:
    - default: `'stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))'
- **after_super** `replace`
  - object: `'stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''stock.lot.type'.replace('.', '_')'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `template_lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'
- **after_super** `cursor`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor_select`
  - files:
    - `product.py`
  - args: `*template_lot_type.select(template_lot_type.template, distinct_on=template_lot_type.template)`
  - code:
    '(connection.cursor()).execute(*template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `template_lot_type.template`
  - kwargs:
    - distinct_on: `template_lot_type.template`
  - code:
    'template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template)'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id).select(lot_type.code, where=template_lot_type.template == template_id)`
  - code:
    '(connection.cursor()).execute(*template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id)`
  - files:
    - `product.py`
  - args: `lot_type.code`
  - kwargs:
    - where: `template_lot_type.template == template_id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id)'
- **after_super** `join`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `lot_type`
  - kwargs:
    - condition: `template_lot_type.type == lot_type.id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)'
- **after_super** `sql_format`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cls.lot_required`
  - files:
    - `product.py`
  - args: `[t for t, in cursor]`
  - code:
    'cls.lot_required.sql_format([t for t, in (connection.cursor())])'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'product.template-stock.lot.type', template_lot_type_table_name`
  - code:
    'table_h.drop_table('product.template-stock.lot.type',
                (config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'stock.lot.type', lot_type_table_name`
  - code:
    'table_h.drop_table('stock.lot.type', (config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'


### 6.0

- **before_super** `Pool`
  - files:
    - `res.py`
  - code:
    'Pool()'
- **before_super** `Transaction`
  - files:
    - `res.py`
  - code:
    'Transaction()'
- **after_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `res.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `Pool`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - code:
    'Pool()'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `action_model, Concat('|', sql_table.action_function)`
  - code:
    'Concat((model.select(
                model.model, where=model.id == sql_table.action_model)), Concat(
                                '|', sql_table.action_function))'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `'|', sql_table.action_function`
  - code:
    'Concat(
                                '|', sql_table.action_function)'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `configuration.py`
  - args: `cls._table`
  - code:
    'backend.TableHandler.table_exist(cls._table)'
- **after_super** `get_cc_module`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - args: `*type.split('_', 1)`
  - code:
    'get_cc_module(*type.split('_', 1))'
- **after_super** `split`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `type`
  - files:
    - `party.py`
  - args: `'_', 1`
  - code:
    'type.split('_', 1)'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'code'`
  - code:
    'table_h.column_exist('code')'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'suffix_code'`
  - code:
    'table_h.column_exist('suffix_code')'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `product.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `product.py`
  - args: `ProductCostPrice._table`
  - code:
    'backend.TableHandler.table_exist(
            ProductCostPrice._table)'
- **after_super** `TableHandler`
  - condition: `not exist and cost_price_exist`
  - object: `backend`
  - files:
    - `product.py`
  - args: `ProductCostPrice, module_name`
  - code:
    'backend.TableHandler(
                ProductCostPrice, module_name)'


### 6.2

- **before_super** `column_exist`
  - condition: `exist`
  - object: `table`
  - files:
    - `party.py`
  - args: `'company'`
  - code:
    'table.column_exist('company')'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.configuration', cls._configuration_value_field, cls, cls._configuration_value_field`
  - kwargs:
    - fields: `['company']`
  - code:
    'migrate_property(
                'party.configuration', cls._configuration_value_field,
                cls, cls._configuration_value_field, fields=['company'])'
- **after_super** `_migrate_property`
  - condition: `not exist`
  - object: `super(PartyLang, cls)`
  - files:
    - `party.py`
  - args: `field_names, value_names, fields`
  - code:
    'super(PartyLang, cls)._migrate_property(
            field_names, value_names, fields)'
- **after_super** `super`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `PartyLang, cls`
  - code:
    'super(PartyLang, cls)'
- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `country.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **after_super** `Transaction`
  - files:
    - `action.py`
  - code:
    'Transaction()'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `Concat(attachment.digest, '-'), attachment.collision`
  - code:
    'Concat(Concat(attachment.digest, '-'),
                            attachment.collision)'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `attachment.digest, '-'`
  - code:
    'Concat(attachment.digest, '-')'
- **after_super** `in_`
  - object: `model_data_sql_table.fs_id`
  - files:
    - `module.py`
  - args: `button_fs_ids`
  - code:
    'model_data_sql_table.fs_id.in_(button_fs_ids)'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `translation.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `timedelta`
  - condition: `table.column_exist('minimum_delay')`
  - object: `datetime`
  - files:
    - `trigger.py`
  - kwargs:
    - hours: `delay`
  - code:
    'datetime.timedelta(hours=(datetime.timedelta(hours=delay)))'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `Coalesce(sql_table.street, ''), Concat('\n', Coalesce(sql_table.streetbis, ''))`
  - code:
    'Concat(
                Coalesce(sql_table.street, ''),
                Concat('\n', Coalesce(sql_table.streetbis, '')))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.street, ''`
  - code:
    'Coalesce(sql_table.street, '')'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `'\n', Coalesce(sql_table.streetbis, '')`
  - code:
    'Concat('\n', Coalesce(sql_table.streetbis, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.streetbis, ''`
  - code:
    'Coalesce(sql_table.streetbis, '')'
- **after_super** `execute`
  - condition: `table_h.column_exist('country')`
  - object: `cursor`
  - files:
    - `address.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.update(
                [table.language_code],
                language.select(
                    Substring(language.code, 0, 2),
                    where=language.id == table.language))))'
- **after_super** `Substring`
  - condition: `table_h.column_exist('language')`
  - files:
    - `address.py`
  - args: `language.code, 0, 2`
  - code:
    'Substring(language.code, 0, 2)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'party.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'party.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `execute`
  - condition: `party_h.column_exist('lang')`
  - object: `cursor`
  - files:
    - `party.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.insert(
                    [table.party, table.lang],
                    party.select(party.id, party.lang))))'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.party', field_names, cls, value_names`
  - kwargs:
    - parent: `'party'`
    - fields: `fields`
  - code:
    'migrate_property(
            'party.party', field_names, cls, value_names,
            parent='party', fields=fields)'
- **after_super** `cls`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - kwargs:
    - party: `party_id`
    - code: `code`
    - type: `type`
  - code:
    'cls(party=party_id, code=code, type=type)'
- **after_super** `save`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `cls`
  - files:
    - `party.py`
  - args: `identifiers`
  - code:
    'cls.save(identifiers)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'product.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'product.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `product.py`
  - args: `'product.template', field_names, cls, value_names`
  - kwargs:
    - parent: `'template'`
    - fields: `fields`
  - code:
    'migrate_property(
            'product.template', field_names, cls, value_names,
            parent='template', fields=fields)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `sql_table, c`
  - code:
    'Column(sql_table, c)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `cost_price, c`
  - code:
    'Column(cost_price, c)'
- **after_super** `select`
  - condition: `table.column_exist('template')`
  - object: `sql_table.join(product, condition=sql_table.template == product.template)`
  - files:
    - `product.py`
  - args: `*[Column(sql_table, c) for c in columns] + [product.id]`
  - kwargs:
    - where: `(sql_table.template != Null) & (sql_table.product == Null)`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        ).select(
                        *[Column(sql_table, c) for c in columns]
                        + [product.id],
                        where=(sql_table.template != Null)
                        & (sql_table.product == Null))'
- **after_super** `join`
  - condition: `table.column_exist('template')`
  - object: `sql_table`
  - files:
    - `product.py`
  - args: `product`
  - kwargs:
    - condition: `sql_table.template == product.template`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        )'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'production.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'production.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'sha1$', Concat(sqltable.password, Concat('$', Coalesce(sqltable.salt, '')))`
  - code:
    'Concat('sha1$', Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, ''))))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.password, Concat('$', Coalesce(sqltable.salt, ''))`
  - code:
    'Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, '')))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'$', Coalesce(sqltable.salt, '')`
  - code:
    'Concat('$', Coalesce(sqltable.salt, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.salt, ''`
  - code:
    'Coalesce(sqltable.salt, '')'
- **before_super** `cursor`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'product.template-stock.lot.type'`
  - kwargs:
    - default: `'product.template-stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))'
- **after_super** `replace`
  - object: `'product.template-stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''product.template-stock.lot.type' .replace('.', '_')'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'stock.lot.type'`
  - kwargs:
    - default: `'stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))'
- **after_super** `replace`
  - object: `'stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''stock.lot.type'.replace('.', '_')'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `template_lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'
- **after_super** `cursor`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor_select`
  - files:
    - `product.py`
  - args: `*template_lot_type.select(template_lot_type.template, distinct_on=template_lot_type.template)`
  - code:
    '(connection.cursor()).execute(*template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `template_lot_type.template`
  - kwargs:
    - distinct_on: `template_lot_type.template`
  - code:
    'template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template)'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id).select(lot_type.code, where=template_lot_type.template == template_id)`
  - code:
    '(connection.cursor()).execute(*template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id)`
  - files:
    - `product.py`
  - args: `lot_type.code`
  - kwargs:
    - where: `template_lot_type.template == template_id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id)'
- **after_super** `join`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `lot_type`
  - kwargs:
    - condition: `template_lot_type.type == lot_type.id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)'
- **after_super** `sql_format`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cls.lot_required`
  - files:
    - `product.py`
  - args: `[t for t, in cursor]`
  - code:
    'cls.lot_required.sql_format([t for t, in (connection.cursor())])'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'product.template-stock.lot.type', template_lot_type_table_name`
  - code:
    'table_h.drop_table('product.template-stock.lot.type',
                (config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'stock.lot.type', lot_type_table_name`
  - code:
    'table_h.drop_table('stock.lot.type', (config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'


### 6.4

- **before_super** `Pool`
  - files:
    - `res.py`
  - code:
    'Pool()'
- **before_super** `Transaction`
  - files:
    - `res.py`
  - code:
    'Transaction()'
- **after_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `res.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `Pool`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - code:
    'Pool()'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `action_model, Concat('|', sql_table.action_function)`
  - code:
    'Concat((model.select(
                model.model, where=model.id == sql_table.action_model)), Concat(
                                '|', sql_table.action_function))'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `'|', sql_table.action_function`
  - code:
    'Concat(
                                '|', sql_table.action_function)'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `configuration.py`
  - args: `cls._table`
  - code:
    'backend.TableHandler.table_exist(cls._table)'
- **after_super** `get_cc_module`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - args: `*type.split('_', 1)`
  - code:
    'get_cc_module(*type.split('_', 1))'
- **after_super** `split`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `type`
  - files:
    - `party.py`
  - args: `'_', 1`
  - code:
    'type.split('_', 1)'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'code'`
  - code:
    'table_h.column_exist('code')'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'suffix_code'`
  - code:
    'table_h.column_exist('suffix_code')'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `product.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `product.py`
  - args: `ProductCostPrice._table`
  - code:
    'backend.TableHandler.table_exist(
            ProductCostPrice._table)'
- **after_super** `TableHandler`
  - condition: `not exist and cost_price_exist`
  - object: `backend`
  - files:
    - `product.py`
  - args: `ProductCostPrice, module_name`
  - code:
    'backend.TableHandler(
                ProductCostPrice, module_name)'


### 6.6

- **before_super** `column_exist`
  - condition: `exist`
  - object: `table`
  - files:
    - `party.py`
  - args: `'company'`
  - code:
    'table.column_exist('company')'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.configuration', cls._configuration_value_field, cls, cls._configuration_value_field`
  - kwargs:
    - fields: `['company']`
  - code:
    'migrate_property(
                'party.configuration', cls._configuration_value_field,
                cls, cls._configuration_value_field, fields=['company'])'
- **after_super** `_migrate_property`
  - condition: `not exist`
  - object: `super(PartyLang, cls)`
  - files:
    - `party.py`
  - args: `field_names, value_names, fields`
  - code:
    'super(PartyLang, cls)._migrate_property(
            field_names, value_names, fields)'
- **after_super** `super`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `PartyLang, cls`
  - code:
    'super(PartyLang, cls)'
- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `country.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **after_super** `Transaction`
  - files:
    - `action.py`
  - code:
    'Transaction()'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `Concat(attachment.digest, '-'), attachment.collision`
  - code:
    'Concat(Concat(attachment.digest, '-'),
                            attachment.collision)'
- **after_super** `Concat`
  - condition: `table.column_exist('digest') and table.column_exist('collision')`
  - files:
    - `attachment.py`
  - args: `attachment.digest, '-'`
  - code:
    'Concat(attachment.digest, '-')'
- **after_super** `in_`
  - object: `model_data_sql_table.fs_id`
  - files:
    - `module.py`
  - args: `button_fs_ids`
  - code:
    'model_data_sql_table.fs_id.in_(button_fs_ids)'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `translation.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `timedelta`
  - condition: `table.column_exist('minimum_delay')`
  - object: `datetime`
  - files:
    - `trigger.py`
  - kwargs:
    - hours: `delay`
  - code:
    'datetime.timedelta(hours=(datetime.timedelta(hours=delay)))'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `Coalesce(sql_table.street, ''), Concat('\n', Coalesce(sql_table.streetbis, ''))`
  - code:
    'Concat(
                Coalesce(sql_table.street, ''),
                Concat('\n', Coalesce(sql_table.streetbis, '')))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.street, ''`
  - code:
    'Coalesce(sql_table.street, '')'
- **after_super** `Concat`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `'\n', Coalesce(sql_table.streetbis, '')`
  - code:
    'Concat('\n', Coalesce(sql_table.streetbis, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('streetbis')`
  - files:
    - `address.py`
  - args: `sql_table.streetbis, ''`
  - code:
    'Coalesce(sql_table.streetbis, '')'
- **after_super** `execute`
  - condition: `table_h.column_exist('country')`
  - object: `cursor`
  - files:
    - `address.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.update(
                [table.language_code],
                language.select(
                    Substring(language.code, 0, 2),
                    where=language.id == table.language))))'
- **after_super** `Substring`
  - condition: `table_h.column_exist('language')`
  - files:
    - `address.py`
  - args: `language.code, 0, 2`
  - code:
    'Substring(language.code, 0, 2)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'party.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'party.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `execute`
  - condition: `party_h.column_exist('lang')`
  - object: `cursor`
  - files:
    - `party.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.insert(
                    [table.party, table.lang],
                    party.select(party.id, party.lang))))'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `party.py`
  - args: `'party.party', field_names, cls, value_names`
  - kwargs:
    - parent: `'party'`
    - fields: `fields`
  - code:
    'migrate_property(
            'party.party', field_names, cls, value_names,
            parent='party', fields=fields)'
- **after_super** `cls`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - kwargs:
    - party: `party_id`
    - code: `code`
    - type: `type`
  - code:
    'cls(party=party_id, code=code, type=type)'
- **after_super** `save`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `cls`
  - files:
    - `party.py`
  - args: `identifiers`
  - code:
    'cls.save(identifiers)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'product.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'product.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `product.py`
  - args: `'product.template', field_names, cls, value_names`
  - kwargs:
    - parent: `'template'`
    - fields: `fields`
  - code:
    'migrate_property(
            'product.template', field_names, cls, value_names,
            parent='template', fields=fields)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `sql_table, c`
  - code:
    'Column(sql_table, c)'
- **after_super** `Column`
  - condition: `cost_price_table.column_exist('template')`
  - files:
    - `product.py`
  - args: `cost_price, c`
  - code:
    'Column(cost_price, c)'
- **after_super** `select`
  - condition: `table.column_exist('template')`
  - object: `sql_table.join(product, condition=sql_table.template == product.template)`
  - files:
    - `product.py`
  - args: `*[Column(sql_table, c) for c in columns] + [product.id]`
  - kwargs:
    - where: `(sql_table.template != Null) & (sql_table.product == Null)`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        ).select(
                        *[Column(sql_table, c) for c in columns]
                        + [product.id],
                        where=(sql_table.template != Null)
                        & (sql_table.product == Null))'
- **after_super** `join`
  - condition: `table.column_exist('template')`
  - object: `sql_table`
  - files:
    - `product.py`
  - args: `product`
  - kwargs:
    - condition: `sql_table.template == product.template`
  - code:
    'sql_table.join(product,
                        condition=sql_table.template == product.template
                        )'
- **after_super** `migrate_property`
  - condition: `not exist`
  - files:
    - `configuration.py`
  - args: `'production.configuration', field_names, cls, value_names`
  - kwargs:
    - fields: `fields`
  - code:
    'migrate_property(
            'production.configuration', field_names, cls, value_names,
            fields=fields)'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'sha1$', Concat(sqltable.password, Concat('$', Coalesce(sqltable.salt, '')))`
  - code:
    'Concat('sha1$', Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, ''))))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.password, Concat('$', Coalesce(sqltable.salt, ''))`
  - code:
    'Concat(sqltable.password,
                Concat('$', Coalesce(sqltable.salt, '')))'
- **after_super** `Concat`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `'$', Coalesce(sqltable.salt, '')`
  - code:
    'Concat('$', Coalesce(sqltable.salt, ''))'
- **after_super** `Coalesce`
  - condition: `table.column_exist('password') and table.column_exist('salt')`
  - files:
    - `user.py`
  - args: `sqltable.salt, ''`
  - code:
    'Coalesce(sqltable.salt, '')'
- **before_super** `cursor`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'product.template-stock.lot.type'`
  - kwargs:
    - default: `'product.template-stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))'
- **after_super** `replace`
  - object: `'product.template-stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''product.template-stock.lot.type' .replace('.', '_')'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'stock.lot.type'`
  - kwargs:
    - default: `'stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))'
- **after_super** `replace`
  - object: `'stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''stock.lot.type'.replace('.', '_')'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `template_lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'
- **after_super** `cursor`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor_select`
  - files:
    - `product.py`
  - args: `*template_lot_type.select(template_lot_type.template, distinct_on=template_lot_type.template)`
  - code:
    '(connection.cursor()).execute(*template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `template_lot_type.template`
  - kwargs:
    - distinct_on: `template_lot_type.template`
  - code:
    'template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template)'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id).select(lot_type.code, where=template_lot_type.template == template_id)`
  - code:
    '(connection.cursor()).execute(*template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id)`
  - files:
    - `product.py`
  - args: `lot_type.code`
  - kwargs:
    - where: `template_lot_type.template == template_id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id)'
- **after_super** `join`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `lot_type`
  - kwargs:
    - condition: `template_lot_type.type == lot_type.id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)'
- **after_super** `sql_format`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cls.lot_required`
  - files:
    - `product.py`
  - args: `[t for t, in cursor]`
  - code:
    'cls.lot_required.sql_format([t for t, in (connection.cursor())])'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'product.template-stock.lot.type', template_lot_type_table_name`
  - code:
    'table_h.drop_table('product.template-stock.lot.type',
                (config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'stock.lot.type', lot_type_table_name`
  - code:
    'table_h.drop_table('stock.lot.type', (config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'


### 6.8

- **before_super** `Pool`
  - files:
    - `res.py`
  - code:
    'Pool()'
- **before_super** `Transaction`
  - files:
    - `res.py`
  - code:
    'Transaction()'
- **after_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `res.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `Pool`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - code:
    'Pool()'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `action_model, Concat('|', sql_table.action_function)`
  - code:
    'Concat((model.select(
                model.model, where=model.id == sql_table.action_model)), Concat(
                                '|', sql_table.action_function))'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `'|', sql_table.action_function`
  - code:
    'Concat(
                                '|', sql_table.action_function)'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `configuration.py`
  - args: `cls._table`
  - code:
    'backend.TableHandler.table_exist(cls._table)'
- **after_super** `get_cc_module`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - files:
    - `party.py`
  - args: `*type.split('_', 1)`
  - code:
    'get_cc_module(*type.split('_', 1))'
- **after_super** `split`
  - condition: `party_h.column_exist('vat_number') and party_h.column_exist('vat_country')`
  - object: `type`
  - files:
    - `party.py`
  - args: `'_', 1`
  - code:
    'type.split('_', 1)'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'code'`
  - code:
    'table_h.column_exist('code')'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'suffix_code'`
  - code:
    'table_h.column_exist('suffix_code')'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `product.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `table_exist`
  - object: `backend.TableHandler`
  - files:
    - `product.py`
  - args: `ProductCostPrice._table`
  - code:
    'backend.TableHandler.table_exist(
            ProductCostPrice._table)'


### 7.0

- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `country.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `export.py`
  - args: `'user'`
  - code:
    'table_h.column_exist('user')'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `trigger.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **after_super** `Transaction`
  - files:
    - `trigger.py`
  - code:
    'Transaction()'
- **after_super** `execute`
  - condition: `table_h.column_exist('country')`
  - object: `cursor`
  - files:
    - `address.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.update(
                [table.language_code],
                language.select(
                    Substring(language.code, 0, 2),
                    where=language.id == table.language))))'
- **after_super** `Substring`
  - condition: `table_h.column_exist('language')`
  - files:
    - `address.py`
  - args: `language.code, 0, 2`
  - code:
    'Substring(language.code, 0, 2)'
- **after_super** `cls`
  - files:
    - `configuration.py`
  - args: `1`
  - code:
    'cls(1)'
- **after_super** `tuple`
  - condition: `configuration.identifier_types`
  - files:
    - `configuration.py`
  - args: `map(replace_vat, configuration.identifier_types)`
  - code:
    'tuple(map(
                    replace_vat, configuration.identifier_types))'
- **after_super** `map`
  - condition: `configuration.identifier_types`
  - files:
    - `configuration.py`
  - args: `replace_vat, configuration.identifier_types`
  - code:
    'map(
                    replace_vat, configuration.identifier_types)'
- **after_super** `sql_format`
  - condition: `configuration.identifier_types != identifier_types`
  - object: `cls.identifier_types`
  - files:
    - `configuration.py`
  - args: `identifier_types`
  - code:
    'cls.identifier_types.sql_format(identifier_types)'
- **after_super** `replace_vat`
  - files:
    - `party.py`
  - args: `old`
  - code:
    'replace_vat(old)'
- **before_super** `cursor`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'product.template-stock.lot.type'`
  - kwargs:
    - default: `'product.template-stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))'
- **after_super** `replace`
  - object: `'product.template-stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''product.template-stock.lot.type' .replace('.', '_')'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'stock.lot.type'`
  - kwargs:
    - default: `'stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))'
- **after_super** `replace`
  - object: `'stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''stock.lot.type'.replace('.', '_')'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `template_lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'
- **after_super** `cursor`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor_select`
  - files:
    - `product.py`
  - args: `*template_lot_type.select(template_lot_type.template, distinct_on=template_lot_type.template)`
  - code:
    '(connection.cursor()).execute(*template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `template_lot_type.template`
  - kwargs:
    - distinct_on: `template_lot_type.template`
  - code:
    'template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template)'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id).select(lot_type.code, where=template_lot_type.template == template_id)`
  - code:
    '(connection.cursor()).execute(*template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id)`
  - files:
    - `product.py`
  - args: `lot_type.code`
  - kwargs:
    - where: `template_lot_type.template == template_id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id)'
- **after_super** `join`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `lot_type`
  - kwargs:
    - condition: `template_lot_type.type == lot_type.id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)'
- **after_super** `sql_format`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cls.lot_required`
  - files:
    - `product.py`
  - args: `[t for t, in cursor]`
  - code:
    'cls.lot_required.sql_format([t for t, in (connection.cursor())])'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'product.template-stock.lot.type', template_lot_type_table_name`
  - code:
    'table_h.drop_table('product.template-stock.lot.type',
                (config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'stock.lot.type', lot_type_table_name`
  - code:
    'table_h.drop_table('stock.lot.type', (config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'


### 7.2

- **before_super** `Pool`
  - files:
    - `res.py`
  - code:
    'Pool()'
- **before_super** `Transaction`
  - files:
    - `res.py`
  - code:
    'Transaction()'
- **after_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `res.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `model.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **after_super** `Pool`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - code:
    'Pool()'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `action_model, Concat('|', sql_table.action_function)`
  - code:
    'Concat((model.select(
                model.model, where=model.id == sql_table.action_model)), Concat(
                                '|', sql_table.action_function))'
- **after_super** `Concat`
  - condition: `table_h.column_exist('action_model') and table_h.column_exist('action_function')`
  - files:
    - `trigger.py`
  - args: `'|', sql_table.action_function`
  - code:
    'Concat(
                                '|', sql_table.action_function)'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'code'`
  - code:
    'table_h.column_exist('code')'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'suffix_code'`
  - code:
    'table_h.column_exist('suffix_code')'


### 7.4

- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `country.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `export.py`
  - args: `'user'`
  - code:
    'table_h.column_exist('user')'
- **after_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `trigger.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **after_super** `Transaction`
  - files:
    - `trigger.py`
  - code:
    'Transaction()'
- **after_super** `execute`
  - condition: `table_h.column_exist('country')`
  - object: `cursor`
  - files:
    - `address.py`
  - args: `*query`
  - code:
    '(Transaction().connection.cursor()).execute(*(table.update(
                [table.language_code],
                language.select(
                    Substring(language.code, 0, 2),
                    where=language.id == table.language))))'
- **after_super** `Substring`
  - condition: `table_h.column_exist('language')`
  - files:
    - `address.py`
  - args: `language.code, 0, 2`
  - code:
    'Substring(language.code, 0, 2)'
- **after_super** `cls`
  - files:
    - `configuration.py`
  - args: `1`
  - code:
    'cls(1)'
- **after_super** `tuple`
  - condition: `configuration.identifier_types`
  - files:
    - `configuration.py`
  - args: `map(replace_vat, configuration.identifier_types)`
  - code:
    'tuple(map(
                    replace_vat, configuration.identifier_types))'
- **after_super** `map`
  - condition: `configuration.identifier_types`
  - files:
    - `configuration.py`
  - args: `replace_vat, configuration.identifier_types`
  - code:
    'map(
                    replace_vat, configuration.identifier_types)'
- **after_super** `sql_format`
  - condition: `configuration.identifier_types != identifier_types`
  - object: `cls.identifier_types`
  - files:
    - `configuration.py`
  - args: `identifier_types`
  - code:
    'cls.identifier_types.sql_format(identifier_types)'
- **after_super** `replace_vat`
  - files:
    - `party.py`
  - args: `old`
  - code:
    'replace_vat(old)'
- **before_super** `cursor`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'product.template-stock.lot.type'`
  - kwargs:
    - default: `'product.template-stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))'
- **after_super** `replace`
  - object: `'product.template-stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''product.template-stock.lot.type' .replace('.', '_')'
- **after_super** `get`
  - object: `config`
  - files:
    - `product.py`
  - args: `'table', 'stock.lot.type'`
  - kwargs:
    - default: `'stock.lot.type'.replace('.', '_')`
  - code:
    'config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))'
- **after_super** `replace`
  - object: `'stock.lot.type'`
  - files:
    - `product.py`
  - args: `'.', '_'`
  - code:
    ''stock.lot.type'.replace('.', '_')'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `template_lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `Table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - files:
    - `product.py`
  - args: `lot_type_table_name`
  - code:
    'Table((config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'
- **after_super** `cursor`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `connection`
  - files:
    - `product.py`
  - code:
    'connection.(connection.cursor())()'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor_select`
  - files:
    - `product.py`
  - args: `*template_lot_type.select(template_lot_type.template, distinct_on=template_lot_type.template)`
  - code:
    '(connection.cursor()).execute(*template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `template_lot_type.template`
  - kwargs:
    - distinct_on: `template_lot_type.template`
  - code:
    'template_lot_type.select(
                    template_lot_type.template,
                    distinct_on=template_lot_type.template)'
- **after_super** `execute`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cursor`
  - files:
    - `product.py`
  - args: `*template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id).select(lot_type.code, where=template_lot_type.template == template_id)`
  - code:
    '(connection.cursor()).execute(*template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id))'
- **after_super** `select`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type.join(lot_type, condition=template_lot_type.type == lot_type.id)`
  - files:
    - `product.py`
  - args: `lot_type.code`
  - kwargs:
    - where: `template_lot_type.template == template_id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)
                    .select(
                        lot_type.code,
                        where=template_lot_type.template == template_id)'
- **after_super** `join`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `template_lot_type`
  - files:
    - `product.py`
  - args: `lot_type`
  - kwargs:
    - condition: `template_lot_type.type == lot_type.id`
  - code:
    'template_lot_type
                    .join(lot_type,
                        condition=template_lot_type.type == lot_type.id)'
- **after_super** `sql_format`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `cls.lot_required`
  - files:
    - `product.py`
  - args: `[t for t, in cursor]`
  - code:
    'cls.lot_required.sql_format([t for t, in (connection.cursor())])'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'product.template-stock.lot.type', template_lot_type_table_name`
  - code:
    'table_h.drop_table('product.template-stock.lot.type',
                (config.get(
            'table', 'product.template-stock.lot.type',
            default='product.template-stock.lot.type' .replace('.', '_'))))'
- **after_super** `drop_table`
  - condition: `table_h.table_exist(template_lot_type_table_name) and table_h.table_exist(lot_type_table_name)`
  - object: `table_h`
  - files:
    - `product.py`
  - args: `'stock.lot.type', lot_type_table_name`
  - code:
    'table_h.drop_table('stock.lot.type', (config.get(
            'table', 'stock.lot.type',
            default='stock.lot.type'.replace('.', '_'))))'


### 7.6

- **before_super** `Transaction`
  - files:
    - `export.py`
  - code:
    'Transaction()'
- **before_super** `Pool`
  - files:
    - `model.py`
  - code:
    'Pool()'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `model.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'


### 7.8

- **before_super** `cursor`
  - object: `Transaction().connection`
  - files:
    - `export.py`
  - code:
    'Transaction().connection.(Transaction().connection.cursor())()'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `export.py`
  - args: `'user'`
  - code:
    'table_h.column_exist('user')'
- **after_super** `cls`
  - files:
    - `configuration.py`
  - args: `1`
  - code:
    'cls(1)'
- **after_super** `tuple`
  - condition: `configuration.identifier_types`
  - files:
    - `configuration.py`
  - args: `map(replace_vat, configuration.identifier_types)`
  - code:
    'tuple(map(
                    replace_vat, configuration.identifier_types))'
- **after_super** `map`
  - condition: `configuration.identifier_types`
  - files:
    - `configuration.py`
  - args: `replace_vat, configuration.identifier_types`
  - code:
    'map(
                    replace_vat, configuration.identifier_types)'
- **after_super** `sql_format`
  - condition: `configuration.identifier_types != identifier_types`
  - object: `cls.identifier_types`
  - files:
    - `configuration.py`
  - args: `identifier_types`
  - code:
    'cls.identifier_types.sql_format(identifier_types)'
- **after_super** `replace_vat`
  - files:
    - `party.py`
  - args: `old`
  - code:
    'replace_vat(old)'


### 8.0

- **before_super** `Transaction`
  - files:
    - `export.py`
  - code:
    'Transaction()'
- **before_super** `Pool`
  - files:
    - `model.py`
  - code:
    'Pool()'
- **before_super** `cursor`
  - object: `transaction.connection`
  - files:
    - `model.py`
  - code:
    'transaction.connection.(transaction.connection.cursor())()'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `party.py`
  - args: `'code'`
  - code:
    'table_h.column_exist('code')'
- **before_super** `column_exist`
  - object: `table_h`
  - files:
    - `party.py`
  - args: `'code_compact'`
  - code:
    'table_h.column_exist('code_compact')'