Python හි සම්බන්ධතා වගුව හරහා සම්බන්ධ කිරීම

දැන් පරිශීලකයා විවිධ නගරවල සිටි යුතු යැයි සිතමු. මෙම අවස්ථාවේ දී, පරිශීලකයන්ගේ වගුවට පහත ස්වරූපය තිබිය හැකිය:

පරිශීලකයන් (users)
id	නම	නගරය
1	user1	city1, city2, city3
2	user2	city1, city2
3	user3	city2, city3
4	user4	city1

දත්ත මේ ආකාරයෙන් ගබඩා කිරීම නුසුදුසු බව පැහැදිලිය - නගර වෙනම වගුවකට ගෙන යා යුතුය. එය මෙන්න:

නගර (cities)
id	නම
1	city1
2	city2
3	city3

කෙසේ වෙතත්, අපට එක් එක් පරිශීලකයාට නගර කිහිපයකට යොමු වීමට හැකි වන පරිදි කළ යුතුය. වගු දෙකක් භාවිතයෙන් මෙය කළ නොහැකිය.

අපට අවශ්ය වන්නේ ඊනියා සම්බන්ධතා වගුව (junction table) හඳුන්වා දීමයි, එය පරිශීලකයා ඔහුගේ නගර සමඟ සම්බන්ධ කරයි.

මෙම වගුවේ සෑම ඇතුළත් කිරීමකම පරිශීලකයෙකු සහ එක් නගරයක් අතර සම්බන්ධතාවය ගබඩා වේ. මෙයින් අදහස් කරන්නේ එක් පරිශීලකයෙකු සඳහා මෙම වගුවේ ඇතුළත් කිරීම් තිබෙන තරම්, ඔහු සිටි නගර ගණන බවයි.

අපගේ සම්බන්ධතා වගුව මෙන්න:

users_cities
id	user_id	city_id
1	1	1
2	1	2
3	1	3
4	2	1
5	2	2
6	3	2
7	3	3
8	4	1

පරිශීලකයන්ගේ වගුව ගබඩා කරන්නේ පරිශීලකයන්ගේ නම් පමණක්, සම්බන්ධතා නොමැතිව:

පරිශීලකයන් (users)
id	නම
1	user1
2	user2
3	user3
4	user4
5	user5

විමසුම් (Queries)

අපි ඔවුන්ගේ නගර සමඟ පරිශීලකයන් ලබා ගන්නා විමසුමක් සාදමු. මේ සඳහා අපට ජොයින් (join) දෙකක් කිරීමට අවශ්ය වනු ඇත: පළමු ජොයින් පරිශීලකයන්ට සම්බන්ධතා වගුව එකතු කරන අතර, දෙවන ජොයින් සම්බන්ධතා හරහා නගර එකතු කරයි:

SELECT
	users.name as user_name, cities.name as city_name
FROM
	users
LEFT JOIN users_cities ON users_cities.user_id=users.id
LEFT JOIN cities ON users_cities.city_id=cities.id

විමසුම් ප්‍රතිඵලය

Python හි අපගේ විමසුමේ ප්‍රතිඵලය අඩංගු වන්නේ එක් එක් පරිශීලකයාගේ නම ඔහු සම්බන්ධ වූ නගර ගණනට අනුව එම ගණනක් වරක් වේ:

{'user_name': 'user1', 'city_name': 'city1'}
{'user_name': 'user1', 'city_name': 'city2'}
{'user_name': 'user1', 'city_name': 'city3'}
{'user_name': 'user2', 'city_name': 'city1'}
{'user_name': 'user2', 'city_name': 'city2'}
{'user_name': 'user3', 'city_name': 'city2'}
{'user_name': 'user3', 'city_name': 'city3'}
{'user_name': 'user4', 'city_name': 'city1'}
{'user_name': 'user5', 'city_name': None}

එවැනි ශබ්දකෝෂයක් පරිවර්තනය කිරීම සහ එය පහත ස්වරූපයට පරිවර්තනය කිරීම වඩාත් පහසු වනු ඇත:

{
	'user1': ['city1', 'city2', 'city3'],
	'user2': ['city1', 'city2'],
	'user3': ['city2', 'city3'],
	'user4': ['city1'],
	'user5': []
}

එවැනි පරිවර්තනයක් සිදු කරන කේතය ලියමු. හිස් ශබ්දකෝෂයක් user_cities_dct සාදමු, එයට අපි ක්‍රමයෙන් දත්ත පරිශීලකයන් සහ ඔවුන් සිටි නගර පිළිබඳව ඇතුළත් කරමු. for ලූපය තුළ අපි අඛණ්ඩව විචල්‍ය දෙකක් user_name සහ city_name ප්‍රකාශ කරමු, එහි පරිශීලකයාගේ නම සහ නගරයේ නම ගබඩා වේ. ඊළඟට අපි කොන්දේසියක් ලියන්නෙමු - එනම් user_cities_dct හි පරිශීලකයා නොමැති නම්, ඔහු මෙම ශබ්දකෝෂයට යතුරක් ලෙස එකතු වනු ඇත. එසේම city_name යනු None නොවේ නම්, එය යතුරේ අගය ලෙස එකතු වන බව ද කොන්දේසියක් සකසමු:

result = cursor.fetchall()

user_cities_dct = {}

for row in result:
	user_name = row['user_name']
	city_name = row['city_name']

	if user_name not in user_cities_dct:
		user_cities_dct[user_name] = []
	if city_name is not None:
		user_cities_dct[user_name].append(city_name)

print(user_cities_dct)

ප්‍රායෝගික කාර්යයන්

එක් නිෂ්පාදනයකට (product) වර්ග කිහිපයක් (categories) අයත් විය හැකි යැයි සිතමු. ගබඩා කිරීමේ ව්‍යුහය විස්තර කරන්න.

නිෂ්පාදන ඒවායේ වර්ග සමඟ ලබා ගන්නා විමසුමක් ලියන්න.

ලබාගත් දත්ත ul ලැයිස්තුවක් ලෙස ප්‍රදර්ශනය කරන්න, එහි සෑම li එකකම පළමුව නිෂ්පාදන නම පෙන්වන අතර ඊට පසු කොලොන් ලකුණකින්, කොමාවකින් වෙන් කර එම නිෂ්පාදනයේ වර්ග ලැයිස්තුගත කරන්න. උදාහරණයක් ලෙස:

<ul>
	<li>product1: category1, category2, category3</li>
	<li>product2: category1, category3</li>
	<li>product3: category1</li>
</ul>