ಈ ಅಧ್ಯಯನದಲ್ಲಿ, PostgreSQL ಗಿಂತ ಕ್ಲಿಕ್‌ಹೌಸ್ ಡೇಟಾ ಮೂಲವನ್ನು ಬಳಸಿಕೊಂಡು ಯಾವ ಕಾರ್ಯಕ್ಷಮತೆ ಸುಧಾರಣೆಗಳನ್ನು ಸಾಧಿಸಬಹುದು ಎಂಬುದನ್ನು ನೋಡಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ಕ್ಲಿಕ್‌ಹೌಸ್ ಬಳಸುವುದರಿಂದ ನಾನು ಪಡೆಯುವ ಉತ್ಪಾದಕತೆಯ ಪ್ರಯೋಜನಗಳು ನನಗೆ ತಿಳಿದಿದೆ. ನಾನು ವಿದೇಶಿ ಡೇಟಾ ರ್ಯಾಪರ್ (FDW) ಅನ್ನು ಬಳಸಿಕೊಂಡು PostgreSQL ನಿಂದ ClickHouse ಅನ್ನು ಪ್ರವೇಶಿಸಿದರೆ ಈ ಪ್ರಯೋಜನಗಳು ಮುಂದುವರಿಯುತ್ತದೆಯೇ?
ಅಧ್ಯಯನ ಮಾಡಿದ ಡೇಟಾಬೇಸ್ ಪರಿಸರಗಳು PostgreSQL v11, clickhousedb_fdw ಮತ್ತು ClickHouse ಡೇಟಾಬೇಸ್. ಅಂತಿಮವಾಗಿ, PostgreSQL v11 ನಿಂದ ನಾವು ನಮ್ಮ clickhousedb_fdw ಮೂಲಕ ಕ್ಲಿಕ್‌ಹೌಸ್ ಡೇಟಾಬೇಸ್‌ಗೆ ವಿವಿಧ SQL ಪ್ರಶ್ನೆಗಳನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತೇವೆ. ಸ್ಥಳೀಯ PostgreSQL ಮತ್ತು ಸ್ಥಳೀಯ ಕ್ಲಿಕ್‌ಹೌಸ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅದೇ ಪ್ರಶ್ನೆಗಳಿಗೆ FDW ನ ಕಾರ್ಯಕ್ಷಮತೆಯು ಹೇಗೆ ಹೋಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ನಂತರ ನೋಡುತ್ತೇವೆ.
ಕ್ಲಿಕ್‌ಹೌಸ್ ಡೇಟಾಬೇಸ್
ಕ್ಲಿಕ್‌ಹೌಸ್ ಎಂಬುದು ಓಪನ್ ಸೋರ್ಸ್ ಸ್ತಂಭಾಕಾರದ ಡೇಟಾಬೇಸ್ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯಾಗಿದ್ದು, ಇದು ಸಾಂಪ್ರದಾಯಿಕ ಡೇಟಾಬೇಸ್ ವಿಧಾನಗಳಿಗಿಂತ 100-1000 ಪಟ್ಟು ವೇಗವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸಾಧಿಸಬಲ್ಲದು, ಒಂದು ಸೆಕೆಂಡಿಗಿಂತ ಕಡಿಮೆ ಅವಧಿಯಲ್ಲಿ ಒಂದು ಶತಕೋಟಿ ಸಾಲುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ.
Clickhousedb_fdw
clickhousedb_fdw - ClickHouse ಡೇಟಾಬೇಸ್ ಅಥವಾ FDW ಗಾಗಿ ಬಾಹ್ಯ ಡೇಟಾ ಹೊದಿಕೆಯು ಪರ್ಕೋನಾದಿಂದ ಮುಕ್ತ ಮೂಲ ಯೋಜನೆಯಾಗಿದೆ. .
.
ನೀವು ನೋಡುವಂತೆ, ಇದು PostgreSQL v11 ಸರ್ವರ್‌ನಿಂದ ಕ್ಲಿಕ್‌ಹೌಸ್ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಆಯ್ಕೆ ಮಾಡಲು ಮತ್ತು ಸೇರಿಸಲು ಅನುಮತಿಸುವ ಕ್ಲಿಕ್‌ಹೌಸ್‌ಗಾಗಿ FDW ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
FDW ಸಮುಚ್ಚಯ ಮತ್ತು ಸೇರುವಂತಹ ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಈ ಸಂಪನ್ಮೂಲ-ತೀವ್ರ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ರಿಮೋಟ್ ಸರ್ವರ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ.
ಬೆಂಚ್ಮಾರ್ಕ್ ಪರಿಸರ
- ಸೂಪರ್‌ಮೈಕ್ರೋ ಸರ್ವರ್:
- Intel® Xeon® CPU E5-2683 v3 @ 2.00GHz
- 2 ಸಾಕೆಟ್ಗಳು / 28 ಕೋರ್ಗಳು / 56 ಎಳೆಗಳು
- ಮೆಮೊರಿ: 256 ಜಿಬಿ RAM
- ಸಂಗ್ರಹಣೆ: Samsung SM863 1.9TB ಎಂಟರ್‌ಪ್ರೈಸ್ SSD
- ಫೈಲ್‌ಸಿಸ್ಟಮ್: ext4/xfs
- OS: Linux smblade01 4.15.0-42-generic #45~16.04.1-Ubuntu
- PostgreSQL: ಆವೃತ್ತಿ 11
ಬೆಂಚ್ಮಾರ್ಕ್ ಪರೀಕ್ಷೆಗಳು
ಈ ಪರೀಕ್ಷೆಗಾಗಿ ಕೆಲವು ಯಂತ್ರ-ರಚಿತ ಡೇಟಾ ಸೆಟ್ ಅನ್ನು ಬಳಸುವ ಬದಲು, ನಾವು 1987 ರಿಂದ 2018 ರವರೆಗೆ "ಸಮಯ ವರದಿ ಮಾಡಿದ ಆಪರೇಟರ್ ಸಮಯದ ಉತ್ಪಾದಕತೆ" ಡೇಟಾವನ್ನು ಬಳಸಿದ್ದೇವೆ. ನೀವು ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು .
ಡೇಟಾಬೇಸ್ ಗಾತ್ರವು 85 GB ಆಗಿದೆ, ಇದು 109 ಕಾಲಮ್‌ಗಳ ಒಂದು ಟೇಬಲ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಬೆಂಚ್ಮಾರ್ಕ್ ಪ್ರಶ್ನೆಗಳು
ClickHouse, clickhousedb_fdw ಮತ್ತು PostgreSQL ಅನ್ನು ಹೋಲಿಸಲು ನಾನು ಬಳಸಿದ ಪ್ರಶ್ನೆಗಳು ಇಲ್ಲಿವೆ.
Q#
ಪ್ರಶ್ನೆಯು ಸಮುಚ್ಚಯಗಳು ಮತ್ತು ಗುಂಪುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ
Q1
ಡೇಆಫ್ ವೀಕ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ (*) ಸಿ ಯ ಸಮಯದಿಂದ ಎಲ್ಲಿ ವರ್ಷ >= 2000 ಮತ್ತು ವರ್ಷ <= 2008 ಗ್ರೂಪ್ ಡೇಆಫ್ ವೀಕ್ ಆರ್ಡರ್ ಮೂಲಕ ಸಿ ಡೆಸ್ಕ್;
Q2
ಡೇಆಫ್‌ವೀಕ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ(*) ಸಿ ಡೆಪ್‌ಡಿಲೇ>10 ಮತ್ತು ವರ್ಷ >= 2000 ಮತ್ತು ವರ್ಷ <= 2008 ಗ್ರೂಪ್ ಡೇಆಫ್‌ವೀಕ್ ಪ್ರಕಾರ ಸಿ ಡೆಸ್ಕ್ ಮೂಲಕ ಆದೇಶ;
Q3
ಮೂಲವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ(*) AS c ಅನ್ನು ಆನ್‌ಟೈಮ್‌ನಿಂದ ಎಲ್ಲಿ DepDelay>10 ಮತ್ತು ವರ್ಷ >= 2000 ಮತ್ತು ವರ್ಷ <= 2008 ಗ್ರೂಪ್ ಮೂಲದ ಪ್ರಕಾರ c DESC LIMIT 10;
Q4
ವಾಹಕವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ() ಸಮಯದಿಂದ ಎಲ್ಲಿ DepDelay>10 ಮತ್ತು ವರ್ಷ = 2007 ಗ್ರೂಪ್ ಮೂಲಕ ಕ್ಯಾರಿಯರ್ ಆರ್ಡರ್ ಮೂಲಕ ಎಣಿಕೆ() DESC;
Q5
ಆಯ್ಕೆ a.Carrier, c, c2, c1000/c2 ರಿಂದ c3 ಆಗಿ (ವಾಹಕವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ() ಎಎಸ್ ಸಿ ಆನ್‌ಟೈಮ್‌ನಿಂದ ಎಲ್ಲಿ ಡಿಪ್‌ಡೆಲೇ>10 ಮತ್ತು ವರ್ಷ=2007 ಗ್ರೂಪ್ ಬೈ ಕ್ಯಾರಿಯರ್ ) ಒಂದು ಆಂತರಿಕ ಸೇರ್ಪಡೆ (ವಾಹಕವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ(*) ಸಿ 2 ಆಗಿನ ಸಮಯದಿಂದ ಎಲ್ಲಿ ವರ್ಷ=2007 ಗ್ರೂಪ್ ಬೈ ಕ್ಯಾರಿಯರ್)b ನಲ್ಲಿ a.Carrier=b.Carrier Order C3 DESC ಮೂಲಕ;
Q6
ಆಯ್ಕೆ a.Carrier, c, c2, c1000/c2 ರಿಂದ c3 ಆಗಿ (ವಾಹಕವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ() ಎಎಸ್ ಸಿ ಆನ್‌ಟೈಮ್‌ನಿಂದ ಎಲ್ಲಿ ಡಿಪ್‌ಡೆಲೇ>10 ಮತ್ತು ವರ್ಷ >= 2000 ಮತ್ತು ವರ್ಷ <= 2008 ಗ್ರೂಪ್ ಬೈ ಕ್ಯಾರಿಯರ್) ಒಂದು ಒಳ ಸೇರುವಿಕೆ (ವಾಹಕವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ(*) ಸಿ2 ಆಗಿ ಸಮಯದಿಂದ ಎಲ್ಲಿ ವರ್ಷ >= 2000 ಮತ್ತು ವರ್ಷ <= 2008 ವಾಹಕ ) a.Carrier=b.C3 DESC ಮೂಲಕ ವಾಹಕದ ಆದೇಶ;
Q7
ವಾಹಕವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಸರಾಸರಿ (DepDelay) * 1000 AS c3 ಆನ್‌ಟೈಮ್‌ನಿಂದ ಎಲ್ಲಿ ವರ್ಷ >= 2000 ಮತ್ತು ವರ್ಷ <= 2008 ವಾಹಕದ ಮೂಲಕ ಗುಂಪು;
Q8
ವರ್ಷವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಸರಾಸರಿ (DepDelay) ಆನ್‌ಟೈಮ್ ಗುಂಪಿನಿಂದ ವರ್ಷದಿಂದ ವರ್ಷಕ್ಕೆ;
Q9
ವರ್ಷವನ್ನು ಆಯ್ಕೆಮಾಡಿ, ವರ್ಷದಿಂದ ಆನ್‌ಟೈಮ್ ಗುಂಪಿನಿಂದ c1 ಎಂದು ಎಣಿಕೆ (*);
Q10
ಸರಾಸರಿ (ಸಿಎನ್ಟಿ) ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ (ವರ್ಷ, ತಿಂಗಳು, ಎಣಿಕೆ (*) ಅನ್ನು ಸಮಯದಿಂದ ಆಯ್ಕೆ ಮಾಡಿ ಅಲ್ಲಿ DepDel15=1 ಗುಂಪು ವರ್ಷ, ತಿಂಗಳು) a;
Q11
avg(c1) ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ (ವರ್ಷ,ತಿಂಗಳು,ಎಣಿಕೆ(*) ಅನ್ನು c1 ಆಗಿ ಆನ್‌ಟೈಮ್ ಗುಂಪಿನಿಂದ ವರ್ಷ,ತಿಂಗಳ ಮೂಲಕ ಆಯ್ಕೆಮಾಡಿ) a;
Q12
OriginCityName, DestCityName ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ(*) AS C AS C FROM ontime GROUP by OriginCityName, DestCityName ಆರ್ಡರ್ ಮೂಲಕ ಸಿ ಡೆಸ್ಕ್ ಲಿಮಿಟ್ 10;
Q13
ಒರಿಜಿನ್‌ಸಿಟಿಹೆಸರನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಸಿ ಡೆಸ್ಕ್ ಲಿಮಿಟ್ 10 ರ ಪ್ರಕಾರ ಒರಿಜಿನ್‌ಸಿಟಿ ನೇಮ್ ಆರ್ಡರ್ ಆನ್‌ಟೈಮ್ ಗ್ರೂಪ್‌ನಿಂದ ಸಿ ಎಣಿಕೆ (*);
ಪ್ರಶ್ನೆ ಸೇರುವಿಕೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ
Q14
a.Year, c1/c2 ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ (ವರ್ಷವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಎಣಿಕೆ()1000 ಸಿ1 ಆಗಿ ಎಲ್ಲಿ ಡಿಪ್‌ಡೆಲೇ>ವರ್ಷದ ಪ್ರಕಾರ 10 ಗುಂಪು) ಒಂದು ಆಂತರಿಕ ಸೇರ್ಪಡೆ (ವರ್ಷವನ್ನು ಆಯ್ಕೆಮಾಡಿ, ವರ್ಷದಿಂದ ಆನ್‌ಟೈಮ್ ಗ್ರೂಪ್‌ನಿಂದ ಸಿ2 ನಂತೆ ಎಣಿಕೆ(*) ) b ರಂದು a.Year=b.ವರ್ಷದ ಪ್ರಕಾರ ಒಂದು.ವರ್ಷ;
Q15
ಒಂದು.”ವರ್ಷ”, c1/c2 ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ (“ವರ್ಷ” ಆಯ್ಕೆಮಾಡಿ, ಎಣಿಕೆ()1000 ಫಾನ್‌ಟೈಮ್‌ನಿಂದ c1 ಆಗಿ “DepDelay”>10 ಗುಂಪು “ವರ್ಷ”) ಒಂದು ಒಳ ಸೇರುವಿಕೆ (“ವರ್ಷ” ಆಯ್ಕೆಮಾಡಿ, ಎಣಿಕೆ(*) ಅನ್ನು c2 ನಂತೆ “ವರ್ಷದಿಂದ” ಫಾನ್‌ಟೈಮ್ ಗುಂಪಿನಿಂದ ) b ರಂದು a.”Year”=b. "ವರ್ಷ";
ಕೋಷ್ಟಕ-1: ಮಾನದಂಡದಲ್ಲಿ ಬಳಸಲಾದ ಪ್ರಶ್ನೆಗಳು
ವಿಚಾರಣೆ ಮರಣದಂಡನೆಗಳು
ವಿಭಿನ್ನ ಡೇಟಾಬೇಸ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ರನ್ ಮಾಡಿದಾಗ ಪ್ರತಿಯೊಂದು ಪ್ರಶ್ನೆಗಳ ಫಲಿತಾಂಶಗಳು ಇಲ್ಲಿವೆ: PostgreSQL ಸೂಚಿಕೆಗಳೊಂದಿಗೆ ಮತ್ತು ಇಲ್ಲದೆ, ಸ್ಥಳೀಯ ClickHouse ಮತ್ತು clickhousedb_fdw. ಸಮಯವನ್ನು ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ.
Q#
PostgreSQL
PostgreSQL (ಸೂಚ್ಯಂಕ)
ಕ್ಲಿಕ್‌ಹೌಸ್
clickhousedb_fdw
Q1
27920
19634
23
57
Q2
35124
17301
50
80
Q3
34046
15618
67
115
Q4
31632
7667
25
37
Q5
47220
8976
27
60
Q6
58233
24368
55
153
Q7
30566
13256
52
91
Q8
38309
60511
112
179
Q9
20674
37979
31
81
Q10
34990
20102
56
148
Q11
30489
51658
37
155
Q12
39357
33742
186
1333
Q13
29912
30709
101
384
Q14
54126
39913
124
1364212
Q15
97258
30211
245
259
ಕೋಷ್ಟಕ-1: ಮಾನದಂಡದಲ್ಲಿ ಬಳಸಿದ ಪ್ರಶ್ನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ತೆಗೆದುಕೊಂಡ ಸಮಯ
ಫಲಿತಾಂಶಗಳನ್ನು ವೀಕ್ಷಿಸಿ
ಗ್ರಾಫ್ ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ಪ್ರಶ್ನೆ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ತೋರಿಸುತ್ತದೆ, X ಅಕ್ಷವು ಮೇಲಿನ ಕೋಷ್ಟಕಗಳಿಂದ ಪ್ರಶ್ನೆ ಸಂಖ್ಯೆಯನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು Y ಅಕ್ಷವು ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ತೋರಿಸುತ್ತದೆ. Clickhousedb_fdw ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪೋಸ್ಟ್‌ಗ್ರೆಸ್‌ನಿಂದ ಹಿಂಪಡೆಯಲಾದ ಕ್ಲಿಕ್‌ಹೌಸ್ ಫಲಿತಾಂಶಗಳು ಮತ್ತು ಡೇಟಾವನ್ನು ತೋರಿಸಲಾಗಿದೆ. ಟೇಬಲ್‌ನಿಂದ ನೀವು PostgreSQL ಮತ್ತು ClickHouse ನಡುವೆ ದೊಡ್ಡ ವ್ಯತ್ಯಾಸವಿದೆ ಎಂದು ನೋಡಬಹುದು, ಆದರೆ ClickHouse ಮತ್ತು clickhousedb_fdw ನಡುವೆ ಕನಿಷ್ಠ ವ್ಯತ್ಯಾಸವಿದೆ.
ಈ ಗ್ರಾಫ್ ClickhouseDB ಮತ್ತು clickhousedb_fdw ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ತೋರಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಪ್ರಶ್ನೆಗಳಲ್ಲಿ, ಎಫ್‌ಡಿಡಬ್ಲ್ಯೂ ಓವರ್‌ಹೆಡ್ ಹೆಚ್ಚು ಅಲ್ಲ ಮತ್ತು Q12 ಹೊರತುಪಡಿಸಿ ಅಷ್ಟೇನೂ ಮಹತ್ವದ್ದಾಗಿಲ್ಲ. ಈ ಪ್ರಶ್ನೆಯು ಸೇರ್ಪಡೆಗಳು ಮತ್ತು ಷರತ್ತಿನ ಮೂಲಕ ಆದೇಶವನ್ನು ಒಳಗೊಂಡಿದೆ. ಆರ್ಡರ್ ಬೈ ಗ್ರೂಪ್/ವೈ ಷರತ್ತಿನ ಕಾರಣ, ಆರ್ಡರ್ ಬೈ ಕ್ಲಿಕ್‌ಹೌಸ್‌ಗೆ ಇಳಿಯುವುದಿಲ್ಲ.
ಕೋಷ್ಟಕ 2 ರಲ್ಲಿ ನಾವು Q12 ಮತ್ತು Q13 ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ಸಮಯದ ಜಿಗಿತವನ್ನು ನೋಡುತ್ತೇವೆ. ಮತ್ತೊಮ್ಮೆ, ಇದು ಆರ್ಡರ್ ಬೈ ಷರತ್ತುಗಳಿಂದ ಉಂಟಾಗುತ್ತದೆ. ಇದನ್ನು ದೃಢೀಕರಿಸಲು, ನಾನು ಪ್ರಶ್ನೆಗಳನ್ನು Q-14 ಮತ್ತು Q-15 ಅನ್ನು ಆರ್ಡರ್ ಬೈ ಷರತ್ತಿನೊಂದಿಗೆ ಮತ್ತು ಇಲ್ಲದೆ ಓಡಿದೆ. ಆರ್ಡರ್ ಬೈ ಷರತ್ತು ಇಲ್ಲದೆ ಪೂರ್ಣಗೊಳ್ಳುವ ಸಮಯವು 259 ಮಿ.ಗಳು ಮತ್ತು ಆರ್ಡರ್ ಬೈ ಷರತ್ತು ಜೊತೆಗೆ ಇದು 1364212 ಆಗಿದೆ. ಈ ಪ್ರಶ್ನೆಯನ್ನು ಡೀಬಗ್ ಮಾಡಲು ನಾನು ಎರಡೂ ಪ್ರಶ್ನೆಗಳನ್ನು ವಿವರಿಸುತ್ತಿದ್ದೇನೆ ಮತ್ತು ವಿವರಣೆಯ ಫಲಿತಾಂಶಗಳು ಇಲ್ಲಿವೆ.
Q15: ಷರತ್ತು ಪ್ರಕಾರ ಆದೇಶವಿಲ್ಲದೆ
bm=# EXPLAIN VERBOSE SELECT a."Year", c1/c2
FROM (SELECT "Year", count(*)*1000 AS c1 FROM fontime WHERE "DepDelay" > 10 GROUP BY "Year") a
INNER JOIN(SELECT "Year", count(*) AS c2 FROM fontime GROUP BY "Year") b ON a."Year"=b."Year";Q15: ಷರತ್ತು ಪ್ರಕಾರ ಆದೇಶವಿಲ್ಲದೆ ಪ್ರಶ್ನೆ
QUERY PLAN
Hash Join (cost=2250.00..128516.06 rows=50000000 width=12)
Output: fontime."Year", (((count(*) * 1000)) / b.c2)
Inner Unique: true Hash Cond: (fontime."Year" = b."Year")
-> Foreign Scan (cost=1.00..-1.00 rows=100000 width=12)
Output: fontime."Year", ((count(*) * 1000))
Relations: Aggregate on (fontime)
Remote SQL: SELECT "Year", (count(*) * 1000) FROM "default".ontime WHERE (("DepDelay" > 10)) GROUP BY "Year"
-> Hash (cost=999.00..999.00 rows=100000 width=12)
Output: b.c2, b."Year"
-> Subquery Scan on b (cost=1.00..999.00 rows=100000 width=12)
Output: b.c2, b."Year"
-> Foreign Scan (cost=1.00..-1.00 rows=100000 width=12)
Output: fontime_1."Year", (count(*))
Relations: Aggregate on (fontime)
Remote SQL: SELECT "Year", count(*) FROM "default".ontime GROUP BY "Year"(16 rows)Q14: ಷರತ್ತು ಪ್ರಕಾರ ಆದೇಶದೊಂದಿಗೆ ಪ್ರಶ್ನೆ
bm=# EXPLAIN VERBOSE SELECT a."Year", c1/c2 FROM(SELECT "Year", count(*)*1000 AS c1 FROM fontime WHERE "DepDelay" > 10 GROUP BY "Year") a
INNER JOIN(SELECT "Year", count(*) as c2 FROM fontime GROUP BY "Year") b ON a."Year"= b."Year"
ORDER BY a."Year";Q14: ಷರತ್ತು ಪ್ರಕಾರ ಆದೇಶದೊಂದಿಗೆ ಪ್ರಶ್ನೆ ಯೋಜನೆ
QUERY PLAN
Merge Join (cost=2.00..628498.02 rows=50000000 width=12)
Output: fontime."Year", (((count(*) * 1000)) / (count(*)))
Inner Unique: true Merge Cond: (fontime."Year" = fontime_1."Year")
-> GroupAggregate (cost=1.00..499.01 rows=1 width=12)
Output: fontime."Year", (count(*) * 1000)
Group Key: fontime."Year"
-> Foreign Scan on public.fontime (cost=1.00..-1.00 rows=100000 width=4)
Remote SQL: SELECT "Year" FROM "default".ontime WHERE (("DepDelay" > 10))
ORDER BY "Year" ASC
-> GroupAggregate (cost=1.00..499.01 rows=1 width=12)
Output: fontime_1."Year", count(*) Group Key: fontime_1."Year"
-> Foreign Scan on public.fontime fontime_1 (cost=1.00..-1.00 rows=100000 width=4)
Remote SQL: SELECT "Year" FROM "default".ontime ORDER BY "Year" ASC(16 rows)ತೀರ್ಮಾನಕ್ಕೆ
ಈ ಪ್ರಯೋಗಗಳ ಫಲಿತಾಂಶಗಳು ಕ್ಲಿಕ್‌ಹೌಸ್ ನಿಜವಾಗಿಯೂ ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು Clickhousedb_fdw PostgreSQL ನಿಂದ ClickHouse ನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ. clickhousedb_fdw ಅನ್ನು ಬಳಸುವಾಗ ಕೆಲವು ಓವರ್‌ಹೆಡ್‌ಗಳಿದ್ದರೂ, ಇದು ಅತ್ಯಲ್ಪ ಮತ್ತು ಕ್ಲಿಕ್‌ಹೌಸ್ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಚಲಾಯಿಸುವ ಮೂಲಕ ಸಾಧಿಸಿದ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಹೋಲಿಸಬಹುದು. PostgreSQL ನಲ್ಲಿನ fdw ಅತ್ಯುತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಕ್ಲಿಕ್‌ಹೌಸ್ ಮೂಲಕ ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್
PostgreSQL ಬಳಸಿಕೊಂಡು ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್
ಮೂಲ: www.habr.com