BigQuery ਦਾ ਪਾਈਪ ਸਿੰਟੈਕਸ: SQL ਨੂੰ ਆਸਾਨ, ਤੇਜ਼ ਅਤੇ ਹੋਰ ਪੜ੍ਹਨਯੋਗ ਬਣਾਉਣਾ

ਕੋਈ ਵੀ ਜਿਸਨੇ ਵੀ ਨਾਲ ਕੰਮ ਕੀਤਾ ਹੈ SQL ਇਸ ਨਾਲ ਆਉਣ ਵਾਲੇ ਪਿਆਰ-ਨਫ਼ਰਤ ਦੇ ਰਿਸ਼ਤੇ ਨੂੰ ਜਾਣਦਾ ਹੈ। SQL ਸ਼ਕਤੀਸ਼ਾਲੀ, ਮਿਆਰੀ, ਅਤੇ ਭਾਵਪੂਰਨ ਹੈ - ਪਰ ਇਹ ਪੈਮਾਨੇ 'ਤੇ ਪੜ੍ਹਨ ਅਤੇ ਬਣਾਈ ਰੱਖਣ ਲਈ ਸਭ ਤੋਂ ਅਣਜਾਣ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਤੁਹਾਡੀ ਪੁੱਛਗਿੱਛ ਜਿੰਨੀ ਡੂੰਘੀ ਹੁੰਦੀ ਜਾਂਦੀ ਹੈ, ਓਨਾ ਹੀ ਇਹ ਸਮਝਣਾ ਔਖਾ ਹੁੰਦਾ ਜਾਂਦਾ ਹੈ ਕਿ ਅਸਲ ਵਿੱਚ ਕੀ ਹੋ ਰਿਹਾ ਹੈ ਅਤੇ ਕਿਸ ਕ੍ਰਮ ਵਿੱਚ।

ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ SQL ਉਸ ਕ੍ਰਮ ਵਿੱਚ ਨਹੀਂ ਚਲਦਾ ਜੋ ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ। ਤੁਸੀਂ ਲਿਖ ਕੇ ਸ਼ੁਰੂਆਤ ਕਰਦੇ ਹੋ SELECT, ਪਰ ਡੇਟਾਬੇਸ ਅਸਲ ਵਿੱਚ ਪਹਿਲਾਂ ਇਸਨੂੰ ਪ੍ਰੋਸੈਸ ਨਹੀਂ ਕਰਦਾ। ਇੰਜਣ ਇਸ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ FROM clause, ਫਿਰ ਡੇਟਾ ਨੂੰ ਜੋੜਦਾ ਹੈ, ਇਸਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ, ਇਸਨੂੰ ਇਕੱਠਾ ਕਰਦਾ ਹੈ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਛਾਂਟੀ ਅਤੇ ਪ੍ਰੋਜੈਕਸ਼ਨ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਨਤੀਜਾ ਇੱਕ ਪੁੱਛਗਿੱਛ ਹੈ ਜੋ ਲਿਖੀ ਗਈ ਹੈ ਪਛੜੇ ਇਸਨੂੰ ਚਲਾਉਣ ਦੇ ਤਰੀਕੇ ਦੇ ਸਾਪੇਖਿਕ।

ਸਿੰਟੈਕਸ ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਵਿਚਕਾਰ ਇਹ ਬੇਮੇਲ SQL ਨੂੰ ਬੋਧਾਤਮਕ ਤੌਰ 'ਤੇ ਭਾਰੀ ਅਤੇ ਗਣਨਾਤਮਕ ਤੌਰ 'ਤੇ ਮਹਿੰਗਾ ਬਣਾਉਂਦਾ ਹੈ। ਵਿਸ਼ਲੇਸ਼ਕ ਅਕਸਰ ਸਬਕਿਊਰੀਆਂ ਜਾਂ ਕਾਮਨ ਟੇਬਲ ਐਕਸਪ੍ਰੈਸ਼ਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ (ਸੀ.ਟੀ.ਈ) ਉੱਪਰ ਤੋਂ ਹੇਠਾਂ ਤੱਕ ਦੇ ਪ੍ਰਵਾਹ ਦੀ ਨਕਲ ਕਰਨ ਲਈ, ਬੇਲੋੜੀ ਗੁੰਝਲਤਾ ਅਤੇ ਰਿਡੰਡੈਂਸੀ ਜੋੜਨਾ। ਇੱਥੋਂ ਤੱਕ ਕਿ ਤਜਰਬੇਕਾਰ ਉਪਭੋਗਤਾ ਵੀ ਉਸ ਸਮੱਸਿਆ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਤਰਕ ਦੇ ਨੇਸਟਡ ਬਲਾਕਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਦੇ ਹਨ ਜੋ ਉਹ ਹੱਲ ਕਰ ਰਹੇ ਹਨ।

ਇਸ ਦੇ ਹੱਲ ਲਈ ਸ. ਬਿਗਕੋਰੀ supports1s execute in the same order they are read. Instead of writing logic inside out, you write it step by step, like a data pipeline—each line representing a distinct transformation. The result is SQL that’s easier to understand, easier to debug, and far more intuitive for modern data analysis.

ਉੱਪਰ ਦਿੱਤੀ ਤਸਵੀਰ ਪਾਈਪ ਸਿੰਟੈਕਸ ਦੁਆਰਾ ਹੱਲ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਮੁੱਖ ਸਮੱਸਿਆ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਰਵਾਇਤੀ SQL ਵਿੱਚ, ਵਾਕ-ਕ੍ਰਮ (ਤੁਸੀਂ ਇੱਕ ਪੁੱਛਗਿੱਛ ਕਿਵੇਂ ਲਿਖਦੇ ਹੋ) ਨਾਲ ਗਲਤ ਮੇਲ ਖਾਂਦਾ ਹੈ ਅਰਥ ਕ੍ਰਮ (ਡੇਟਾਬੇਸ ਅਸਲ ਵਿੱਚ ਇਸਨੂੰ ਕਿਵੇਂ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ)। ਉਦਾਹਰਣ ਵਜੋਂ, SELECT ਸਿਖਰ 'ਤੇ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਪਰ ਇੰਜਣ ਇਸਦਾ ਮੁਲਾਂਕਣ ਉਦੋਂ ਤੱਕ ਨਹੀਂ ਕਰਦਾ ਜਦੋਂ ਤੱਕ ਜੁੜਨ ਤੋਂ ਬਾਅਦ, ਫਿਲਟਰਿੰਗ, ਗਰੁੱਪਿੰਗ ਅਤੇ ਸੌਰਟਿੰਗ ਨਹੀਂ ਹੋ ਜਾਂਦੀ।

ਇਹ ਕ੍ਰਮ ਇੱਕ BigQuery ਪਾਈਪ ਪੁੱਛਗਿੱਛ ਦੇ ਲਾਜ਼ੀਕਲ ਅਤੇ ਸਿੰਟੈਕਟਿਕ ਪ੍ਰਵਾਹ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ — ਉੱਪਰ ਤੋਂ ਹੇਠਾਂ, ਖੱਬੇ ਤੋਂ ਸੱਜੇ — ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਡੇਟਾਬੇਸ ਅਸਲ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ।

• ਤੋਂ: ਕਿਸੇ ਵੀ ਪਾਈਪ ਪੁੱਛਗਿੱਛ ਦਾ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ। ਸ਼ੁਰੂਆਤੀ ਟੇਬਲ ਜਾਂ ਸਬਕਿਊਰੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜਿਸ ਤੋਂ ਡੇਟਾ ਪ੍ਰਵਾਹਿਤ ਹੁੰਦਾ ਹੈ। ਪਾਈਪ ਸਿੰਟੈਕਸ ਵਿੱਚ, FROM ਇੱਕ ਵੈਧ ਪੁੱਛਗਿੱਛ ਦੇ ਤੌਰ 'ਤੇ ਇਕੱਲੇ ਖੜ੍ਹੇ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਇੱਕ ਕ੍ਰਮਵਾਰ ਪਾਈਪਲਾਈਨ ਲਈ ਐਂਟਰੀ ਵਜੋਂ ਕੰਮ ਕਰਦੇ ਹਨ।
• ਜੁੜੋ: ਮੌਜੂਦਾ ਟੇਬਲ ਨੂੰ ਕਿਸੇ ਹੋਰ ਟੇਬਲ ਜਾਂ ਸਬਕਵੇਰੀ ਤੋਂ ਵਾਧੂ ਕਾਲਮਾਂ ਅਤੇ ਕਤਾਰਾਂ ਨਾਲ ਵਧਾਉਂਦਾ ਹੈ। ਕ੍ਰਮ ਵਿੱਚ ਕਈ ਵਾਰ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ (|> JOIN table USING (key)), ਖੱਬੇ-ਡੂੰਘੇ ਜੋੜ ਵਾਲੇ ਰੁੱਖਾਂ ਨੂੰ ਨੇਸਟਡ ਸਬਕਿਊਰੀਆਂ ਤੋਂ ਬਿਨਾਂ ਪੜ੍ਹਨਯੋਗ ਬਣਾਉਣਾ।
• ਸੈੱਟ: ਮੌਜੂਦਾ ਕਾਲਮ ਮੁੱਲਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ (|> SET column = expression). ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ SELECT * REPLACE(...) ਸਟੈਂਡਰਡ SQL ਵਿੱਚ ਪਰ ਪਾਈਪਲਾਈਨ ਸਟੈਪ ਵਜੋਂ ਵਰਤੇ ਜਾਣ 'ਤੇ ਇਹ ਵਧੇਰੇ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਮਾਡਿਊਲਰ ਹੁੰਦਾ ਹੈ।
• ਵਧਾਓ: ਮੌਜੂਦਾ ਡੇਟਾਸੈੱਟ ਵਿੱਚ ਗਣਨਾ ਕੀਤੇ ਕਾਲਮ ਜੋੜਦਾ ਹੈ (|> EXTEND expression AS new_column). SELECT* ਦੇ ਸਮਾਨ, ਸਟੈਂਡਰਡ SQL ਵਿੱਚ new_column ਪਰ ਜੋੜਾਂ ਅਤੇ ਫਿਲਟਰਾਂ ਵਰਗੇ ਹੋਰ ਕਾਰਜਾਂ ਦੇ ਵਿਚਕਾਰ ਪ੍ਰਾਪਤ ਖੇਤਰਾਂ ਦੀ ਵਧਦੀ ਰਚਨਾ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
• ਸੁੱਟੋ: ਮੌਜੂਦਾ ਡੇਟਾਸੈੱਟ ਤੋਂ ਇੱਕ ਜਾਂ ਵੱਧ ਕਾਲਮਾਂ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ (|> DROP column_name). ਦੇ ਬਰਾਬਰ SELECT * EXCEPT(column) ਸਟੈਂਡਰਡ SQL ਵਿੱਚ ਅਤੇ ਅਕਸਰ ਆਉਟਪੁੱਟ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਜਾਂ ਵਿਚਕਾਰਲੇ ਡੇਟਾ ਆਕਾਰ ਨੂੰ ਘਟਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
• WHERE: ਇੱਕ ਸ਼ਰਤ ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਾਲੀਆਂ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ (|> WHERE condition). ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਕਿਤੇ ਵੀ ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ, ਏਕੀਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਜਾਂ ਬਾਅਦ ਵਿੱਚ, HAVING ਜਾਂ QUALIFY ਵਰਗੇ ਵੱਖ-ਵੱਖ ਕੀਵਰਡਸ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ।
• ਸਮੂਹ: ਪੂਰੀ-ਸਾਰਣੀ ਜਾਂ ਸਮੂਹਬੱਧ ਸਮੂਹੀਕਰਨ ਕਰਦਾ ਹੈ (|> AGGREGATE SUM(column) AS total GROUP BY category). SELECT ਦੇ ਅੰਦਰ GROUP BY ਅਤੇ ਐਗਰੀਗੇਟ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲਦਾ ਹੈ, ਸੰਟੈਕਸ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਾਰਜਾਂ ਦੇ ਲਾਜ਼ੀਕਲ ਕ੍ਰਮ ਨਾਲ ਇਕਸਾਰ ਕਰਦਾ ਹੈ।
• ਆਰਡਰ ਕਰੋ: ਕਤਾਰਾਂ ਨੂੰ ਵਧਦੇ ਜਾਂ ਘਟਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਦਾ ਹੈ (|> ORDER BY column DESC). ਇੱਕ ਕ੍ਰਮਬੱਧ ਨਤੀਜਾ ਸਾਰਣੀ ਤਿਆਰ ਕਰਦਾ ਹੈ ਜਿਸਦਾ ਪਾਲਣ ਓਪਰੇਟਰਾਂ ਦੁਆਰਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ LIMIT.
• ਸੀਮਾ: ਨਤੀਜੇ ਵਿੱਚ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸੀਮਤ ਕਰਦਾ ਹੈ (|> LIMIT 10). ਬਾਅਦ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ ORDER BY ਜਾਂ ਬਿਨਾਂ ਕ੍ਰਮਬੱਧ ਟੇਬਲਾਂ 'ਤੇ, ਫਿਲਟਰਾਂ ਅਤੇ ਇਕੱਤਰਤਾਵਾਂ ਦੇ ਕੁਦਰਤੀ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹੋਏ।
• ਕਾਲ ਕਰੋ: ਮੌਜੂਦਾ ਟੇਬਲ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਵਰਤਦੇ ਹੋਏ ਇੱਕ ਟੇਬਲ-ਮੁੱਲ ਵਾਲੇ ਫੰਕਸ਼ਨ ਜਾਂ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ (|> CALL ML.PREDICT(MODEL project.model_name)). ਨੇਸਟਡ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ, ਇੱਕ ਲੀਨੀਅਰ ਅਤੇ ਪੜ੍ਹਨਯੋਗ ਵਰਕਫਲੋ ਬਣਾਉਂਦਾ ਹੈ।
• ਚੁਣੋ: ਆਉਟਪੁੱਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਕਾਲਮਾਂ ਦੇ ਅੰਤਿਮ ਪ੍ਰੋਜੈਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ (|> SELECT column1, column2). ਇੱਕ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਸਮਾਪਤੀ ਕਾਰਜ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਫਾਈਨਲ ਵਾਂਗ SELECT ਇੱਕ ਮਿਆਰੀ SQL ਪੁੱਛਗਿੱਛ ਵਿੱਚ।

ਹੇਠਾਂ ਸਭ ਤੋਂ ਆਮ ਦ੍ਰਿਸ਼ ਦਿੱਤੇ ਗਏ ਹਨ ਜਿੱਥੇ ਪਾਈਪ ਸਿੰਟੈਕਸ SQL ਤਰਕ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ, ਪੁੱਛਗਿੱਛਾਂ ਨੂੰ ਸਾਫ਼ ਅਤੇ ਕੰਮ ਕਰਨ ਲਈ ਤੇਜ਼ ਬਣਾਉਂਦਾ ਹੈ।

ਸਬ-ਕਵੇਰੀਆਂ ਤੋਂ ਬਿਨਾਂ ਡੇਟਾ ਇਕੱਠਾ ਕਰਨਾ

ਐਗਰੀਗੇਸ਼ਨ ਉਹ ਥਾਂਵਾਂ ਹਨ ਜਿੱਥੇ SQL ਅੰਦਰੋਂ ਬਾਹਰੋਂ ਮਹਿਸੂਸ ਹੋਣ ਲੱਗਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਕੁਝ ਗਿਣਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਉਹਨਾਂ ਗਿਣਤੀਆਂ ਨੂੰ ਗਿਣੋ, ਤੁਸੀਂ ਅਚਾਨਕ ਬਰੈਕਟਾਂ ਦੇ ਨਰਕ ਵਿੱਚ ਹੋ।

SELECT c_count, COUNT(*) AS custdist
FROM (
  SELECT c_custkey, COUNT(o_orderkey) AS c_count
  FROM customer
  JOIN orders ON c_custkey = o_custkey
  WHERE o_comment NOT LIKE '%unusual%packages%'
  GROUP BY c_custkey
)
GROUP BY c_count
ORDER BY custdist DESC;

FROM customer
|> JOIN orders ON c_custkey = o_custkey
   AND o_comment NOT LIKE '%unusual%packages%'
|> AGGREGATE COUNT(o_orderkey) AS c_count GROUP BY c_custkey
|> AGGREGATE COUNT(*) AS custdist GROUP BY c_count
|> ORDER BY custdist DESC;

ਹੁਣ ਕੋਈ ਨੇਸਟਿੰਗ ਜਾਂ ਡਬਲ ਗਰੁੱਪਿੰਗ ਨਹੀਂ। ਹਰ ਕਦਮ ਤਰਕਪੂਰਨ ਢੰਗ ਨਾਲ ਚਲਦਾ ਹੈ ਅਤੇ ਪੂਰੀ ਪੁੱਛਗਿੱਛ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੇ ਬਿਨਾਂ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਕਦਮ-ਦਰ-ਕਦਮ ਕਾਲਮਾਂ ਦੀ ਸਫਾਈ ਅਤੇ ਰੂਪਾਂਤਰਣ

ਜਦੋਂ ਤੁਹਾਨੂੰ ਛੋਟੇ ਅੱਖਰਾਂ ਵਾਲੇ ਟੈਕਸਟ ਦੀ ਗਣਨਾ ਕਰਨ, ਕੁੱਲ ਗਿਣਤੀ ਕਰਨ ਅਤੇ ਵਾਧੂ ਕਾਲਮ ਛੱਡਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਸਟੈਂਡਰਡ SQL ਤੁਹਾਨੂੰ ਕਈ ਕਾਲਮਾਂ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ SELECT ਸਟੇਟਮੈਂਟ। ਪਾਈਪ ਸਿੰਟੈਕਸ ਪੇਸ਼ ਕਰਦਾ ਹੈ SET, EXTENDਹੈ, ਅਤੇ DROP ਓਪਰੇਟਰ ਤਾਂ ਜੋ ਤੁਸੀਂ ਕ੍ਰਮ ਵਿੱਚ ਬਦਲਾਅ ਲਾਗੂ ਕਰ ਸਕੋ।

SELECT o_custkey, ROUND(o_totalprice) AS total_price
FROM (
  SELECT
    o_custkey,
    o_totalprice,
    LOWER(o_orderstatus) AS o_orderstatus
  FROM orders
)
WHERE total_price > 1000;

FROM orders
|> SET o_orderstatus = LOWER(o_orderstatus)
|> EXTEND ROUND(o_totalprice) AS total_price
|> WHERE total_price > 1000
|> SELECT o_custkey, total_price;

ਹਰੇਕ ਓਪਰੇਸ਼ਨ ਪਿਛਲੇ ਓਪਰੇਸ਼ਨ 'ਤੇ ਬਣਿਆ ਹੁੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਪਰਿਵਰਤਨਾਂ ਨੂੰ ਟਰੇਸ ਕਰਨਾ ਅਤੇ ਤਰਕ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ।

"ਹੋਣਾ" ਯਾਦ ਰੱਖੇ ਬਿਨਾਂ ਐਗਰੀਗੇਸ਼ਨ ਤੋਂ ਬਾਅਦ ਫਿਲਟਰ ਕਰਨਾ

SQL ਦੀ ਇੱਕ ਖਾਸੀਅਤ ਇਹ ਹੈ ਕਿ ਫਿਲਟਰਾਂ ਦਾ ਸਮਾਂ ਧਾਰਾ ਦੇ ਆਧਾਰ 'ਤੇ ਬਦਲਦਾ ਹੈ। ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ WHERE ਸਮੂਹ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ HAVING ਬਾਅਦ, ਪਰ ਅਸਲ ਵਿੱਚ, ਦੋਵੇਂ ਸਿਰਫ਼ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦੇ ਹਨ। ਪਾਈਪ ਸਿੰਟੈਕਸ ਤੁਹਾਨੂੰ ਵਰਤਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ WHERE ਲਗਾਤਾਰ, ਭਾਵੇਂ ਤੁਸੀਂ ਇਸਨੂੰ ਕਿੱਥੇ ਰੱਖੋ।

SELECT department, COUNT(*) AS emp_count
FROM employees
WHERE active = TRUE
GROUP BY department
HAVING COUNT(*) > 5;

FROM employees
|> WHERE active = TRUE
|> AGGREGATE COUNT(*) AS emp_count GROUP BY department
|> WHERE emp_count > 5;

ਹੁਣ ਤੁਸੀਂ ਫਿਲਟਰਾਂ ਨੂੰ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਲਿਖ ਸਕਦੇ ਹੋ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਤੁਸੀਂ ਉਹਨਾਂ ਬਾਰੇ ਸੋਚਦੇ ਹੋ: ਪਹਿਲਾਂ ਡੇਟਾ ਨੂੰ ਫਿਲਟਰ ਕਰੋ, ਫਿਰ ਇਸਨੂੰ ਸਮੂਹ ਕਰੋ, ਫਿਰ ਨਤੀਜਿਆਂ 'ਤੇ ਦੁਬਾਰਾ ਫਿਲਟਰ ਕਰੋ।

ਅਸਥਾਈ ਟੇਬਲਾਂ ਤੋਂ ਬਿਨਾਂ ਪੁੱਛਗਿੱਛਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ

ਸਟੈਂਡਰਡ SQL ਵਿੱਚ, ਇੱਕ ਵਿਚਕਾਰਲੇ ਨਤੀਜੇ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਜਾਂ ਤਾਂ ਇੱਕ ਅਸਥਾਈ ਟੇਬਲ ਬਣਾਉਣ ਜਾਂ ਕੋਡ ਨੂੰ ਕਈ CTEs ਵਿੱਚ ਲਪੇਟਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਪਾਈਪ ਸਿੰਟੈਕਸ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਕਿਸੇ ਵੀ ਬਿੰਦੂ ਤੱਕ ਪੁੱਛਗਿੱਛ ਚਲਾ ਸਕਦੇ ਹੋ।

WITH filtered AS (
  SELECT * FROM orders WHERE o_totalprice > 500
),
summed AS (
  SELECT o_custkey, SUM(o_totalprice) AS total
  FROM filtered GROUP BY o_custkey
)
SELECT * FROM summed WHERE total > 10000;

FROM orders
|> WHERE o_totalprice > 500
|> AGGREGATE SUM(o_totalprice) AS total GROUP BY o_custkey
|> WHERE total > 10000;

ਪੁੱਛਗਿੱਛ ਦਾ ਹਰੇਕ ਪ੍ਰੀਫਿਕਸ ਆਪਣੇ ਆਪ ਹੀ ਚੱਲਣਯੋਗ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਪੜਾਅ 'ਤੇ ਡੇਟਾ ਨੂੰ "ਝਾਕ" ਸਕਦੇ ਹੋ। ਇਹ ਡੀਬੱਗ ਅਤੇ ਦੁਹਰਾਉਣ ਦਾ ਇੱਕ ਸਾਫ਼, ਵਧੇਰੇ ਇੰਟਰਐਕਟਿਵ ਤਰੀਕਾ ਹੈ।

ਆਲ੍ਹਣੇ ਤੋਂ ਬਿਨਾਂ ਮਾਡਲਾਂ ਅਤੇ ਕਾਰਜਾਂ ਨੂੰ ਚੇਨ ਕਰਨਾ

ਟੇਬਲ-ਵੈਲਿਊਡ ਫੰਕਸ਼ਨਾਂ ਜਾਂ BigQuery ML ਮਾਡਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਨੇਸਟਿੰਗ ਜਲਦੀ ਪੜ੍ਹਨਯੋਗ ਨਹੀਂ ਹੋ ਸਕਦੀ। ਪਾਈਪ ਸਿੰਟੈਕਸ ਉਹਨਾਂ ਨੇਸਟਡ ਕਾਲਾਂ ਨੂੰ CALL ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲੀਨੀਅਰ ਚੇਨਿੰਗ ਨਾਲ ਬਦਲ ਦਿੰਦਾ ਹੈ।

SELECT *
FROM ML.PREDICT(
  MODEL `project.sentiment_model`,
  (SELECT text FROM reviews)
);

SELECT text FROM reviews
|> CALL ML.PREDICT(MODEL `project.sentiment_model`);

ਜੇਕਰ ਤੁਸੀਂ ਕਈ ਮਾਡਲ ਜਾਂ ਪਰਿਵਰਤਨ ਲਾਗੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸਿਰਫ਼ ਵਾਧੂ CALL ਲਾਈਨਾਂ ਸਟੈਕ ਕਰਦੇ ਹੋ—ਕੋਈ ਬਰੈਕਟ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਨੇਸਟਡ ਸਿਲੈਕਟਸ ਤੋਂ ਬਿਨਾਂ ਡੇਟਾ ਨੂੰ ਪਿਵੋਟਿੰਗ ਕਰਨਾ

ਡੇਟਾ ਨੂੰ ਪਿਵੋਟ ਕਰਨਾ ਹਮੇਸ਼ਾ ਇੱਕ ਔਖਾ ਪ੍ਰਕਿਰਿਆ ਰਿਹਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਅਕਸਰ ਸਬਕਿਊਰੀਆਂ ਦੀਆਂ ਪਰਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਪਾਈਪ ਸਿੰਟੈਕਸ ਇਸਨੂੰ ਇੱਕ ਵਹਿੰਦੇ ਕ੍ਰਮ ਵਿੱਚ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ।

SELECT *
FROM (
  SELECT n_name, c_acctbal, c_mktsegment
  FROM customer JOIN nation USING (n_nationkey)
)
PIVOT(SUM(c_acctbal) FOR n_name IN ('PERU', 'KENYA', 'JAPAN'));

FROM customer
|> JOIN nation USING (n_nationkey)
|> SELECT n_name, c_acctbal, c_mktsegment
|> PIVOT(SUM(c_acctbal) FOR n_name IN ('PERU', 'KENYA', 'JAPAN'));

ਇਹ ਪੁੱਛਗਿੱਛ ਹੁਣ ਇੱਕ ਕਹਾਣੀ ਵਾਂਗ ਪੜ੍ਹੀ ਜਾ ਰਹੀ ਹੈ: ਆਪਣੇ ਡੇਟਾ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਇਸਨੂੰ ਜੋੜੋ, ਤੁਹਾਨੂੰ ਜੋ ਚਾਹੀਦਾ ਹੈ ਉਸਨੂੰ ਚੁਣੋ, ਫਿਰ ਪਿਵੋਟ ਕਰੋ।

ਪਾਈਪ ਸਿੰਟੈਕਸ ਇੱਕ ਗੇਮ-ਚੇਂਜਰ ਕਿਉਂ ਹੈ

ਪਾਈਪ ਸਿੰਟੈਕਸ SQL ਨੂੰ ਮੁੜ ਖੋਜ ਨਹੀਂ ਕਰਦਾ - ਇਹ ਇਸਨੂੰ ਸਪੱਸ਼ਟ ਕਰਦਾ ਹੈ। ਇਹ SQL ਦੇ ਘੋਸ਼ਣਾਤਮਕ ਢਾਂਚੇ ਬਾਰੇ ਹਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਚੀਜ਼ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ ਪਰ ਤਰਕ ਨੂੰ ਪਿੱਛੇ ਵੱਲ ਲਿਖਣ ਦੇ ਬੋਧਾਤਮਕ ਓਵਰਹੈੱਡ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ।

ਡਾਟਾ ਵਿਗਿਆਨੀਆਂ, ਵਿਸ਼ਲੇਸ਼ਕਾਂ ਅਤੇ ਇੰਜੀਨੀਅਰਾਂ ਲਈ, ਇਸਦਾ ਮਤਲਬ ਹੈ:

• ਪੁੱਛਗਿੱਛਾਂ ਨੂੰ ਪੜ੍ਹਨਾ, ਲਿਖਣਾ ਅਤੇ ਡੀਬੱਗ ਕਰਨਾ ਆਸਾਨ ਹੈ
• ਸਧਾਰਨ ਕੰਮਾਂ ਲਈ ਹੁਣ ਕੋਈ ਜਾਗਲਿੰਗ ਸਬਕਿਊਰੀਆਂ ਜਾਂ CTE ਨਹੀਂ
• ਸੁਚਾਰੂ ਤਰਕ ਜੋ ਤੁਹਾਡੇ ਅਸਲ ਸੋਚਣ ਦੇ ਢੰਗ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ
• ਬਿਹਤਰ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਘੱਟ ਬੇਲੋੜੇ ਕਾਰਜ

BigQuery ਦਾ ਪਾਈਪ ਸਿੰਟੈਕਸ ਆਧੁਨਿਕ ਡਾਟਾ ਯੁੱਗ ਲਈ SQL ਹੈ—ਲੀਨੀਅਰ, ਅਨੁਭਵੀ, ਅਤੇ ਅਸਲ-ਸੰਸਾਰ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਅਨੁਕੂਲਿਤ।

ਸੰਬੰਧਿਤ Martech Zone ਸਮੱਗਰੀ

GA4 ਨਾਲ ਯੂਨੀਵਰਸਲ ਵਿਸ਼ਲੇਸ਼ਣ ਇਤਿਹਾਸਕ ਡੇਟਾ ਦਾ ਬੈਕ-ਅੱਪ ਅਤੇ ਰਿਪੋਰਟ ਕਿਵੇਂ ਕਰੀਏ?

BigQuery: ਡੈਮੋ PII ਨਾਮ, ਪਤਾ, ਈਮੇਲ ਅਤੇ ਫ਼ੋਨ ਨੰਬਰ ਡਾਟਾ ਬਣਾਉਣ ਲਈ SQL ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਸੁਪਰਮੈਟ੍ਰਿਕਸ: ਆਪਣੇ ਮਾਰਕੀਟਿੰਗ ਡੇਟਾ ਨੂੰ ਵਪਾਰਕ ਵਿਕਾਸ ਵਿੱਚ ਐਕਸਟਰੈਕਟ, ਆਟੋਮੇਟ, ਟ੍ਰਾਂਸਫਾਰਮ ਅਤੇ ਸਰਗਰਮ ਕਰੋ

ਗੂਗਲ ਵਿਸ਼ਲੇਸ਼ਣ 4: ਉਪਭੋਗਤਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਜਨਸੰਖਿਆ ਡੇਟਾ ਦਾ ਲਾਭ ਉਠਾ ਕੇ ਇਨਸਾਈਟਸ ਨੂੰ ਕਿਵੇਂ ਵਧਾਇਆ ਜਾਵੇ