'Join a destination table to the current table.
:param implicit: False if the join is an explicit join. This allows
to fall back on the previous implementation of ``join`` before
OpenERP 7.0. It therefore adds the JOIN specified in ``connection``
If True, the join is done implicitely, by adding the table alias
in the from clause and the join condition in the where clause
of the query. Implicit joins do not handle outer, extra, extra_params parameters.
:param connection: a tuple ``(lhs, table, lhs_col, col, link)``.
The join corresponds to the SQL equivalent of::
(lhs.lhs_col = table.col)
Note that all connection elements are strings. Please refer to expression.py for more details about joins.
:param outer: True if a LEFT OUTER JOIN should be used, if possible
(no promotion to OUTER JOIN is supported in case the JOIN
was already present in the query, as for the moment
implicit INNER JOINs are only connected from NON-NULL
columns so it would not be correct (e.g. for
``_inherits`` or when a domain criterion explicitly
adds filtering)
:param extra: A string with the extra join condition (SQL), or None.
This is used to provide an additional condition to the join
clause that cannot be added in the where clause (e.g., for LEFT
JOIN concerns). The condition string should refer to the table
aliases as "{lhs}" and "{rhs}".
:param extra_params: a list of parameters for the `extra` condition.'

def add_join(self, connection, implicit=True, outer=False, extra=None, extra_params=[]):

    from odoo.osv.expression import generate_table_alias
    (lhs, table, lhs_col, col, link) = connection
    (alias, alias_statement) = generate_table_alias(lhs, [(table, link)])
    if implicit:
        if (alias_statement not in self.tables):
            self.tables.append(alias_statement)
            condition = ('("%s"."%s"    =    "%s"."%s")' % (lhs, lhs_col, alias, col))
            self.where_clause.append(condition)
        else:
            pass
        return (alias, alias_statement)
    else:
        aliases = self._get_table_aliases()
        assert (lhs in aliases), ('Left-hand-side    table    %s    must    already    be    part    of    the    query    tables    %s!' % (lhs, str(self.tables)))
        if (alias_statement in self.tables):
            pass
        else:
            self.tables.append(alias_statement)
            join_tuple = (alias, lhs_col, col, ((outer and 'LEFT    JOIN') or 'JOIN'))
            self.joins.setdefault(lhs, []).append(join_tuple)
            if (extra or extra_params):
                extra = (extra or '').format(lhs=lhs, rhs=alias)
                self.extras[(lhs, join_tuple)] = (extra, extra_params)
        return (alias, alias_statement)
