#NEWLINE# def __init__( self , right_table = None , fields = None , condition = None , join_type = 'JOIN' , schema = None , left_table = None , owner = None , extract_fields = True , prefix_fields = True , field_prefix = None ) : #NEWLINE# #INDENT# "\n        Initializes the default values and assigns any passed params\n\n        :param right_table: The table being joined with. This can be a string of the table\n            name, a dict of {'alias': table}, or a ``Table`` instance\n        :type right_table: str or dict or :class:`Table <querybuilder.tables.Table>`\n\n        :param fields: The fields to select from ``table``. Defaults to None. This can be\n            a single field, a tuple of fields, or a list of fields. Each field can be a string\n            or ``Field`` instance\n        :type fields: str or tuple or list or :class:`Field <querybuilder.fields.Field>`\n\n        :param condition: The join condition specifying the fields being joined. If the two tables being\n            joined are instances of ``ModelTable`` then the condition should be created automatically.\n        :type condition: str\n\n        :param join_type: The type of join (JOIN, LEFT JOIN, INNER JOIN, etc). Defaults to 'JOIN'\n        :type join_type: str\n\n        :param schema: This is not implemented, but it will be a string of the db schema name\n        :type schema: str\n\n        :param left_table: The left table being joined with. This can be a string of the table\n            name, a dict of {'alias': table}, or a ``Table`` instance. Defaults to the first table\n            in the query.\n        :type left_table: str or dict or :class:`Table <querybuilder.tables.Table>` or None\n\n        :param owner: A reference to the query managing this Join object\n        :type owner: :class:`Query <querybuilder.query.Query>`\n\n        :param extract_fields: If True and joining with a ``ModelTable``, then '*'\n            fields will be converted to individual fields for each column in the table. Defaults\n            to True.\n        :type extract_fields: bool\n\n        :param prefix_fields: If True, then the joined table will have each of its field names\n            prefixed with the field_prefix. If no field_prefix is specified, a name will be\n            generated based on the join field name. This is usually used with nesting results\n            in order to create models in python or javascript. Defaults to True.\n        :type prefix_fields: bool\n\n        :param field_prefix: The field prefix to be used in front of each field name if prefix_fields\n            is set to True. If no field_prefix is set, one will be automatically created based on\n            the join field name.\n        :type field_prefix: str\n        " #NEWLINE# self . owner = owner #NEWLINE# self . left_table = None #NEWLINE# self . right_table = None #NEWLINE# self . prefix_fields = join_type #NEWLINE# self . condition = condition #NEWLINE# self . join_type = join_type #NEWLINE# self . schema = schema #NEWLINE# self . set_left_table ( left_table = left_table ) #NEWLINE# self . set_right_table ( TableFactory ( table = right_table , fields = fields , extract_fields = extract_fields , prefix_fields = prefix_fields , owner = self . owner , field_prefix = field_prefix ) )