Process data representing relationships between a web of entities - sql

Question

Here are the facts:
There are many companies.
Each company can have many businesses.
There are many addresses.
You don't know which businesses are owned by which companies (or the name of the company).
However, you do know the address of each business and you know a business might trade at more than one address.
Forming relationships between addresses:
If a business has the same address as another then, for the purpose of this question, we will say that they are owned by the same company.
ie A link is formed between two addresses when a business uses both addresses.
So ,an address "A" might be linked to many other addresses.
Note that:
6a. the addresses that address "A" links to might also be linked to one OR MORE addresses.
6b. One of the addresses ""A" links to might link back to "A" via a third address (ie two business that use both these addresses)
A complex example of this is shown in the picture attached. In this picture, there are only two companies. One has the red business, the other has the blue, green and black business.
Here is some example data in tableBA ( I have attached a photo to describe these relationships)
BUSINESS Address
A 1
A 2
B 1
C 3
D 4 < four businesses sharing the same address
E 4
F 4
G 4
W 2
W 5
X 5
X 6
So I want to created code that will create the following output. The output has one name per company and lists the business names that are in the company.
ie there is one row for every complete chain of addresses
A,B,W,X
D,E,F,G
C
This question is an simplification/ improvement on another SO question here.
This answer to the other question uses a combination of SQL and VBA code to solve the problem, because MS Access doesn't support recursive joining.
How can this be done with pure SQL, either with recursive joining or some other technique (not with a stored procedure)?

Answer 1

This is an SQL Server answer.
Quote from this answer:
To clarify:
A business can have multiple addresses
Any business in a business group (AKA company) shares an address with any other business in the group
A business group can own multiple businesses
Each business is only associated with one business group (corollary to second point)
SQL Fiddle with sample data
We can refer to each business group by the first (smallest name in
alphabetical order) business in the group. Let's call this the key
business. After we've identified the key business for each business,
we can group by the key business and get the results.
In order to get the key business:
Generate a list of pairs of businesses where both businesses are in the same group, based on any shared address. This list should exclude
the following (see next point for why):
A -> B, when we have B -> A
A -> A
The left side of the pairs should be unique: each business should appear on the left side of the pair no more than once, if at all.
For each business, follow the pairs from one to the next until the right business is never the left business in any other pair. That is
the key business.
That is the reason for the exclusions in the first point. If we have both A -> B and B -> A, we'll get to a never-ending loop.
Same goes for A -> A.
The following query will return the key business for each business:
WITH Pairs AS (
SELECT Businesses.Business AS Business2, MIN(Businesses_1.Business) AS Business1
FROM Businesses
INNER JOIN Businesses AS Businesses_1 ON Businesses.Address = Businesses_1.Address
WHERE Businesses.Business > Businesses_1.Business
GROUP BY Businesses.Business
),
KeyBusinesses AS (
SELECT Business2 AS Business, Business1 AS KeyBusiness
FROM Pairs
UNION ALL
SELECT Pairs.Business2, KeyBusinesses.KeyBusiness
FROM Pairs
INNER JOIN KeyBusinesses ON Pairs.Business1 = KeyBusinesses.Business
)
SELECT Businesses.*, ISNULL(KeyBusinesses.KeyBusiness, Businesses.Business) AS KeyBusiness
FROM Businesses
LEFT JOIN KeyBusinesses ON Businesses.Business = KeyBusinesses.Business
SQL Fiddle

Answer 2

This is a crude and crappy solution (probably not efficient), but it gets the correct results. It works by maintaining 2 maps to a Company (where a Company contains a list of business-names). First maps business-address to company, 2nd maps business-name to company. if the company is NOT found in either map, a new company is created: -
package test;
import org.junit.Assert;
import org.junit.Test;
import java.util.*;
import java.util.stream.Collectors;
public class Companies {
public static List<Company> listCompanies(List<Business> businesses) {
List<Company> companies = new ArrayList<>();
Map<String, Company> companyByAddress = new HashMap<>(); // map allows many addresses to map to same company
Map<String, Company> companyByBusiness = new HashMap<>(); // map allows many businesses to map to same company
for (Business business : businesses) {
Company company = companyByAddress.get(business.address);
if (company == null)
company = companyByBusiness.get(business.name);
if (company != null) {
company.addAddress(business.name);
} else {
company = new Company();
company.addAddress(business.name);
companies.add(company);
}
companyByBusiness.put(business.name, company);
companyByAddress.put(business.address, company);
}
return companies;
}
#Test
public void testOne() {
List<Business> businesses = new ArrayList<>();
businesses.add(new Business("A", "1"));
businesses.add(new Business("A", "2"));
businesses.add(new Business("B", "1"));
businesses.add(new Business("C", "3"));
businesses.add(new Business("D", "4"));
businesses.add(new Business("E", "4"));
businesses.add(new Business("F", "4"));
businesses.add(new Business("G", "4"));
businesses.add(new Business("W", "2"));
businesses.add(new Business("W", "5"));
businesses.add(new Business("X", "5"));
businesses.add(new Business("X", "6"));
List<Company> companies = listCompanies(businesses);
Assert.assertEquals("A, B, W, X", companies.get(0));
Assert.assertEquals("C", companies.get(1));
Assert.assertEquals("D, E, F, G", companies.get(2));
}
static class Business {
private final String name;
private final String address;
Business(String business, String address) {
this.name = business;
this.address = address;
}
}
static class Company {
private final Set<String> addresses; // Being a "Set", each address will occur only once
Company() {
this.addresses = new LinkedHashSet<>(); // A "LinkedHashSet" preserves insertion order
}
void addAddress(String address) {
addresses.add(address);
}
#Override
public String toString() {
return addresses.stream().collect(Collectors.joining(", "));
}
}
}