Performs Left Outer Join
            :return left_outer: dict
7382
def left_outer(self):
        
        self.get_collections_data()
        left_outer_join = self.merge_join_docs(
            set(self.collections_data['left'].keys()))
        return left_outer_join
568687
def build_joins(self):
        
        join_parts = []

        # get the sql for each join object
        for join_item in self.joins:
            join_parts.append(join_item.get_sql())

        # if there are any joins, combine them
        if len(join_parts):
            combined_joins = ' '.join(join_parts)
            return '{0} '.format(combined_joins)
        return ''
96714
def inner(self):
        
        self.get_collections_data()

        inner_join = self.merge_join_docs(set(self.collections_data['left'].keys()) & set(
            self.collections_data['right'].keys()))

        return inner_join
381983
def dict(self):
        
        SKIP_KEYS = ('_source_table', '_dest_table', 'd_vid', 't_vid', 'st_id',
                     'dataset', 'hash', 'process_records')
        return OrderedDict([(k, getattr(self, k)) for k in self.properties if k not in SKIP_KEYS])
318862
def _get_all(self):
        
        return [self._to_dict(row) for row in models.User.objects.all()]
705786
def execute_cross_join(op, left, right, **kwargs):
    
    # generate a unique name for the temporary join key
    key = "cross_join_{}".format(ibis.util.guid())
    join_key = {key: True}
    new_left = left.assign(**join_key)
    new_right = right.assign(**join_key)

    # inner/outer doesn't matter because every row matches every other row
    result = pd.merge(
        new_left,
        new_right,
        how='inner',
        on=key,
        copy=False,
        suffixes=constants.JOIN_SUFFIXES,
    )

    # remove the generated key
    del result[key]

    return result
1346117
def value_left(self, other):
    
    return other.value if isinstance(other, self.__class__) else other
1043134
def get_l(self):
        """"""

        cell_left = CellBorders(self.cell_attributes,
                                *self.cell.get_left_key_rect())
        return cell_left.get_r()
1129117
def get_diff(left, right):
    
    res = {'+': [], '-': []}

    def partition(objects):
        """Partition the passed object list."""
        res = {}
        for o in objects:
            t = type(o)
            if type(o) not in res:
                res[t] = []
            res[t].append(o)
        return res

    def get_not_included(foo, bar):
        """Compare objects from foo with objects defined in the values of
        bar (set of partitions).
        Returns a list of all objects included in list, but not dict values.
        """
        res = []
        for o in foo:
            if not compat.object_in_list(type(o), bar):
                res.append(o)
            elif not compat.object_in_list(o, bar[type(o)]):
                res.append(o)
        return res

    # Create partitions of both lists. This will reduce the time required for
    # the comparison
    left_objects = partition(left)
    right_objects = partition(right)
    # and then do the diff
    res['+'] = get_not_included(right, left_objects)
    res['-'] = get_not_included(left, right_objects)
    return res
764209
function LeftJoin(Table $table, Condition $condition, $prepend = false)
    {
        return $this->Join($table, JoinType::Left(), $condition, $prepend);
    }
573114
def _join(self, node):
        

        select_block = str(node.attributes)
        from_block = '{left} {operator} {right}'.format(
            left=self._join_helper(node.left),
            right=self._join_helper(node.right),
            operator=self._get_sql_operator(node))

        if node.operator == Operator.theta_join:
            from_block = '{from_block} ON {conditions}'.format(
                from_block=from_block,
                conditions=node.conditions)

        return self.query(select_block, from_block, '')
264798
def left_joins(*args)
			return self if args.compact.blank?

			relation = clone

			args.flatten!

			#	args could be just a single symbol
			#		...could be an array of symbols (
			#		...could be a hash (joins(:address => :address_type))
			#		...could be a string (SQL)

			#	here I really am just expecting an array of model names as a symbols

			#	this only works if the primary and foreign keys are conventional

			#	@klass (or its reader klass() ) is the calling class (Organization)
			#	@table (or its reader table() ) is the calling class's Arel::Table


#	StudySubject
# scope :join_patients, joins(
#   Arel::Nodes::OuterJoin.new(Patient.arel_table,Arel::Nodes::On.new(
#     self.arel_table[:id].eq(Patient.arel_table[:study_subject_id]))))
# scope :join_patients, left_joins(:patient)	#	WORKS

#	Organization
# scope :without_sample_location, joins(
#   Arel::Nodes::OuterJoin.new(
#     SampleLocation.arel_table,Arel::Nodes::On.new(
#       self.arel_table[:id].eq(SampleLocation.arel_table[:organization_id]))))
# scope :without_sample_location, left_joins(:sample_location)	#	WORKS
#
#	Organization has one Sample Location

# scope :without_hospital, joins(
#   Arel::Nodes::OuterJoin.new(
#     Hospital.arel_table,Arel::Nodes::On.new(
#       self.arel_table[:id].eq(Hospital.arel_table[:organization_id]))))
# scope :without_hospital, left_joins(:hospital)	#	WORKS

#	Organization has one Hospital


#		@zip_codes = ZipCode.joins(
#			Arel::Nodes::OuterJoin.new(County.arel_table,Arel::Nodes::On.new(
#				ZipCode.arel_table[:county_id].eq(County.arel_table[:id]))))
#
#		@zip_codes = ZipCode.left_joins(:county) #??? backwards? won't work?

#	ZipCode belongs to County



#	doesn't work on has_one or has_many ... :through


			args.each do |arg|	#	no, I'm not a pirate
				reflection = klass.reflections[arg]
				joining_model = reflection.klass
#
#	:has_one and probably :has_many	( BUT NOT :belongs_to )
#
				relation.joins_values += [
					Arel::Nodes::OuterJoin.new(
						joining_model.arel_table,
( reflection.macro == :belongs_to ) ?
						Arel::Nodes::On.new(
							table[ reflection.foreign_key ].eq(
#								joining_model.arel_table[ :id ]
								joining_model.arel_table[ reflection.options[:primary_key] || :id ]
							)
						) :
						Arel::Nodes::On.new(
							table[:id].eq(		#	won't ALWAYS be :id
								joining_model.arel_table[ reflection.foreign_key ]
							)
						)

					)
				]




			end	#	args.each do |arg|	#	no, I'm not a pirate

			relation
		end
542867
def _minimize_joins(self):
        
        joins_group = []
        for join in self._joins:
            append_new = True
            for join_group in joins_group:
                if join_group[0]['table'] == join['table'] and join_group[0]['ons'] == join['ons']:
                    join_group.append(join)
                    append_new = False
                    break
            if append_new:
                joins_group.append([join])

        self._joins = []
        for joins in joins_group:
            if len(joins) > 1 and any(bool(join['type'] == INNER_JOIN) for join in joins):
                joins[0]['type'] = INNER_JOIN
                self._joins.append(joins[0])
            elif len(joins) > 1 and all(join['type'] == joins[0]['type'] for join in joins):
                self._joins.append(joins[0])
            else:
                self._joins.extend(joins)
268418
def _get_merge_keys(self):
        
        left_keys = []
        right_keys = []
        join_names = []
        right_drop = []
        left_drop = []

        left, right = self.left, self.right

        is_lkey = lambda x: is_array_like(x) and len(x) == len(left)
        is_rkey = lambda x: is_array_like(x) and len(x) == len(right)

        # Note that pd.merge_asof() has separate 'on' and 'by' parameters. A
        # user could, for example, request 'left_index' and 'left_by'. In a
        # regular pd.merge(), users cannot specify both 'left_index' and
        # 'left_on'. (Instead, users have a MultiIndex). That means the
        # self.left_on in this function is always empty in a pd.merge(), but
        # a pd.merge_asof(left_index=True, left_by=...) will result in a
        # self.left_on array with a None in the middle of it. This requires
        # a work-around as designated in the code below.
        # See _validate_specification() for where this happens.

        # ugh, spaghetti re #733
        if _any(self.left_on) and _any(self.right_on):
            for lk, rk in zip(self.left_on, self.right_on):
                if is_lkey(lk):
                    left_keys.append(lk)
                    if is_rkey(rk):
                        right_keys.append(rk)
                        join_names.append(None)  # what to do?
                    else:
                        if rk is not None:
                            right_keys.append(
                                right._get_label_or_level_values(rk))
                            join_names.append(rk)
                        else:
                            # work-around for merge_asof(right_index=True)
                            right_keys.append(right.index)
                            join_names.append(right.index.name)
                else:
                    if not is_rkey(rk):
                        if rk is not None:
                            right_keys.append(
                                right._get_label_or_level_values(rk))
                        else:
                            # work-around for merge_asof(right_index=True)
                            right_keys.append(right.index)
                        if lk is not None and lk == rk:
                            # avoid key upcast in corner case (length-0)
                            if len(left) > 0:
                                right_drop.append(rk)
                            else:
                                left_drop.append(lk)
                    else:
                        right_keys.append(rk)
                    if lk is not None:
                        left_keys.append(left._get_label_or_level_values(lk))
                        join_names.append(lk)
                    else:
                        # work-around for merge_asof(left_index=True)
                        left_keys.append(left.index)
                        join_names.append(left.index.name)
        elif _any(self.left_on):
            for k in self.left_on:
                if is_lkey(k):
                    left_keys.append(k)
                    join_names.append(None)
                else:
                    left_keys.append(left._get_label_or_level_values(k))
                    join_names.append(k)
            if isinstance(self.right.index, MultiIndex):
                right_keys = [lev._values.take(lev_codes) for lev, lev_codes
                              in zip(self.right.index.levels,
                                     self.right.index.codes)]
            else:
                right_keys = [self.right.index._values]
        elif _any(self.right_on):
            for k in self.right_on:
                if is_rkey(k):
                    right_keys.append(k)
                    join_names.append(None)
                else:
                    right_keys.append(right._get_label_or_level_values(k))
                    join_names.append(k)
            if isinstance(self.left.index, MultiIndex):
                left_keys = [lev._values.take(lev_codes) for lev, lev_codes
                             in zip(self.left.index.levels,
                                    self.left.index.codes)]
            else:
                left_keys = [self.left.index.values]

        if left_drop:
            self.left = self.left._drop_labels_or_levels(left_drop)

        if right_drop:
            self.right = self.right._drop_labels_or_levels(right_drop)

        return left_keys, right_keys, join_names
1254952
def currentGrouping( self ):
        
        groupBy = self.groupBy()
        if ( groupBy == XOrbBrowserWidget.GroupByAdvancedKey ):
            return self.advancedGrouping()
        else:
            table = self.tableType()
            if ( not table ):
                return []
            
            for column in table.schema().columns():
                if ( column.displayName() == groupBy ):
                    return [column.name()]
            
            return []
1131070
def select_join(self, table, field, join_table, join_field):
        
        sql = "select {table}.{field} from {table} left join {join_table} "\
              "on {table}.{field}={join_table}.{join_field} "\
              "where {join_table}.{join_field} is null;".format(table=table,
                                                                field=field,
                                                                join_table=join_table,
                                                                join_field=join_field)
        return super(PGWrapper, self).execute(sql, result=True).results
799519
public function left_outer_join($table, $constraint, $table_alias = null)
        {
            return $this->_addJoinSource("LEFT OUTER", $table, $constraint, $table_alias);
        }