SQL ਫਾਰਮੈਟਰ ਅਤੇ ਵੈਲੀਡੇਟਰ

ਕਿਉਂ SQL ਫਾਰਮੈਟਿੰਗ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਕੀ ਤੁਸੀਂ ਕਦੇ ਇੱਕ ਡੇਟਾਬੇਸ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕੰਮ ਕੀਤਾ ਹੈ ਜਿੱਥੇ SQL ਅਜਿਹਾ ਲੱਗਦਾ ਹੈ ਜਿਵੇਂ ਕਿਸੇ ਨੇ ਅੱਖਾਂ ਬੰਦ ਕਰਕੇ ਟਾਈਪ ਕੀਤਾ ਹੋਵੇ? ਤੁਸੀਂ ਇਕੱਲੇ ਨਹੀਂ ਹੋ। ਖਰਾਬ ਫਾਰਮੈਟ ਕੀਤੀ SQL ਡੇਟਾਬੇਸ ਵਿਕਾਸ ਵਿੱਚ ਬੱਗਾਂ ਅਤੇ ਬਰਬਾਦ ਹੋਏ ਸਮੇਂ ਦਾ ਸਭ ਤੋਂ ਆਮ ਸਰੋਤ ਹੈ।

ਇਹ SQL ਫਾਰਮੈਟਰ ਅਤੇ ਵੈਲੀਡੇਟਰ ਤੁਹਾਨੂੰ ਆਟੋਮੈਟਿਕ ਤੌਰ 'ਤੇ ਗੰਦੇ ਕਵੇਰੀਆਂ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਆਪਣੀ SQL ਪੇਸਟ ਕਰੋ, ਅਤੇ ਇਹ ਤੁਰੰਤ ਸਹੀ ਇੰਡੈਂਟੇਸ਼ਨ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਕੀਵਰਡਾਂ ਨੂੰ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਲਿਖਦਾ ਹੈ, ਅਤੇ ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ—ਸਭ ਕੁਝ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਬਿਨਾਂ ਕਿਸੇ ਸਰਵਰ 'ਤੇ ਡੇਟਾ ਭੇਜੇ। ਜੋ ਆਮ ਤੌਰ 'ਤੇ 10-15 ਮਿੰਟ ਮੈਨੁਅਲ ਫਾਰਮੈਟਿੰਗ ਲੈਂਦਾ ਹੈ, ਉਹ ਸਕਿੰਟਾਂ ਵਿੱਚ ਹੋ ਜਾਂਦਾ ਹੈ।

ਮੇਰੇ ਡੇਟਾਬੇਸ ਟੀਮਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਤਜਰਬੇ ਵਿੱਚ, ਸਭ ਤੋਂ ਵੱਡੀ ਸਮਾਂ ਬਚਾਉਣ ਵਾਲੀ ਚੀਜ਼ ਸਿਰਫ ਫਾਰਮੈਟਿੰਗ ਨਹੀਂ ਹੈ—ਇਹ ਉਨ੍ਹਾਂ ਗਲਤੀਆਂ ਨੂੰ ਫੜਨਾ ਹੈ ਜੋ ਉਤਪਾਦਨ ਵਿੱਚ ਆਉਣ ਤੋਂ ਪਹਿਲਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੱਕ ਗਲਤ ਰੱਖੀ ਬ੍ਰੈਕਟ ਜਾਂ ਬੰਦ ਨਾ ਕੀਤਾ ਗਿਆ ਕੋਟ ਡੀਬੱਗਿੰਗ ਵਿੱਚ ਘੰਟੇ ਬਰਬਾਦ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਟੂਲ ਉਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਤੁਰੰਤ ਫੜ ਲੈਂਦਾ ਹੈ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਡੇਟਾਬੇਸ ਦੇ ਖਿਲਾਫ਼ ਕੁਝ ਵੀ ਐਗਜ਼ੀਕਿਊਟ ਕਰੋ।

SQL ਫਾਰਮੈਟਰ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਇੰਟਰਫੇਸ ਜਾਣਬੁੱਝ ਕੇ ਬਹੁਤ ਸਧਾਰਨ ਹੈ—ਬੱਸ ਪੇਸਟ ਕਰੋ ਅਤੇ ਚਲਾਓ:

ਆਪਣਾ SQL ਇਨਪੁਟ ਬਾਕਸ ਵਿੱਚ ਪੇਸਟ ਕਰੋ (ਜਾਂ ਸਿੱਧਾ ਟਾਈਪ ਕਰੋ ਜੇਕਰ ਤੁਸੀਂ ਸ਼ੁਰੂ ਤੋਂ ਲਿਖ ਰਹੇ ਹੋ)
ਆਪਣੇ ਟਾਈਪ ਕਰਦੇ ਸਮੇਂ ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਫਾਰਮੈਟ ਹੁੰਦਾ ਵੇਖੋ—ਕੋਈ ਬਟਨ ਨਹੀਂ ਦਬਾਉਣਾ, ਕੋਈ ਸੈਟਿੰਗ ਕੌਨਫਿਗਰ ਨਹੀਂ ਕਰਨੀ
ਵੈਲੀਡੇਸ਼ਨ ਗਲਤੀਆਂ ਦੀ ਸਮੀਖਿਆ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫਾਰਮੈਟ ਕੀਤੇ ਆਉਟਪੁਟ ਦੇ ਹੇਠਾਂ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ
ਫਾਰਮੈਟ ਕੀਤਾ SQL ਇੱਕ ਕਲਿੱਕ ਨਾਲ ਕਾਪੀ ਕਰੋ ਤਾਂ ਜੋ ਆਪਣੇ IDE, ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਜਾਂ ਡੇਟਾਬੇਸ ਟੂਲ ਵਿੱਚ ਵਰਤ ਸਕੋ

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

SQL ਫਾਰਮੈਟਰ ਕੀ ਕਰਦਾ ਹੈ

ਕੀਵਰਡ ਦੀ ਵੱਡੀ ਅੱਖਰ ਵਿੱਚ ਲਿਖਾਈ

ਸਾਰੇ SQL ਕੀਵਰਡ ਆਪਣੇ-ਆਪ ਵੱਡੀ ਅੱਖਰ ਵਿੱਚ ਲਿਖ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ—SELECT, FROM, WHERE, JOIN, ਆਦਿ। ਇਹ ਅਧਿਕਾਂਸ਼ ਡੇਟਾਬੇਸ ਟੀਮਾਂ ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਪਰੰਪਰਾ ਦਾ ਪਾਲਣ ਕਰਦਾ ਹੈ ਅਤੇ ਕੀਵਰਡਾਂ ਨੂੰ ਤੁਹਾਡੇ ਟੇਬਲ ਅਤੇ ਕਾਲਮ ਨਾਮਾਂ ਤੋਂ ਵਿਜ਼ੁਅਲੀ ਵੱਖਰਾ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਜਟਿਲ ਕਵੇਰੀ ਵਿੱਚ ਸਕੈਨ ਕਰ ਰਹੇ ਹੋ, ਇਹ ਵਿਜ਼ੁਅਲ ਵੱਖਰਾਵ ਤੁਹਾਨੂੰ ਕਵੇਰੀ ਦੀ ਸਰੰਚਨਾ ਨੂੰ ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ ਪਛਾਣਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਸਮਾਰਟ ਇੰਡੈਂਟੇਸ਼ਨ

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

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

ਤਰਕ-ਸੰਗਤ ਲਾਈਨ ਬ੍ਰੇਕ

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

ਸਪੇਸਿੰਗ SQL ਸਟਾਈਲ ਗਾਈਡ ਦੀਆਂ ਪਰੰਪਰਾਵਾਂ ਦਾ ਪਾਲਣ ਕਰਦੀ ਹੈ ਜੋ ਉਦਯੋਗ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡਾ ਫਾਰਮੈਟ ਕੀਤਾ SQL ਹੋਰ ਡਿਵੈਲਪਰਾਂ ਲਈ ਪਰਿਚਿਤ ਲੱਗੇਗਾ।

SQL ਵੈਲੀਡੇਸ਼ਨ: ਕੀ ਚੈੱਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

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

ਸਟਰਕਚਰਲ ਗਲਤੀਆਂ

ਅਸੰਤੁਲਿਤ ਬਰੈਕਟ ਜਟਿਲ ਕਵੇਰੀਆਂ ਵਿੱਚ ਅਚਾਨਕ ਆਮ ਹੁੰਦੇ ਹਨ। ਵੈਲੀਡੇਟਰ ਖੁੱਲ੍ਹੇ ਅਤੇ ਬੰਦ ਬਰੈਕਟਾਂ ਦੀ ਗਿਣਤੀ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਬੇਮੇਲ ਨੂੰ ਤੁਰੰਤ ਫਲੈਗ ਕੀਤਾ ਜਾ ਸਕੇ। ਮੈਂ ਉਤਪਾਦਨ ਦੀਆਂ ਘਟਨਾਵਾਂ ਵੇਖੀਆਂ ਹਨ ਜੋ 200-ਲਾਈਨ ਕਵੇਰੀ ਵਿੱਚ ਇੱਕ ਇੱਕ ਬਰੈਕਟ ਦੀ ਘਾਟ ਕਾਰਨ ਹੋਈਆਂ—ਇਹ ਉਨ੍ਹਾਂ ਨੂੰ ਜਲਦੀ ਫੜ ਲੈਂਦਾ ਹੈ।

ਬੰਦ ਨਾ ਕੀਤੇ ਗਏ ਸਟਰਿੰਗ ਲਿਟਰਲ ਤਦ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਤੁਸੀਂ ਸਟਰਿੰਗ ਮੁੱਲ 'ਤੇ ਬੰਦ ਕੋਟ ਭੁੱਲ ਜਾਂਦੇ ਹੋ। ਤੁਹਾਡਾ ਡੇਟਾਬੇਸ ਇਨ੍ਹਾਂ ਨੂੰ ਤੁਰੰਤ ਰੱਦ ਕਰ ਦੇਵੇਗਾ, ਪਰ ਇਨ੍ਹਾਂ ਨੂੰ ਇੱਥੇ ਫੜਨ ਨਾਲ ਇੱਕ ਦੌਰ ਬਚ ਜਾਂਦਾ ਹੈ।

ਕਲਾਜ਼ ਆਰਡਰਿੰਗ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤਦ ਫਲੈਗ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜਦੋਂ ਕਲਾਜ਼ ਕ੍ਰਮ ਤੋਂ ਬਾਹਰ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਜੇ ਤੁਸੀਂ GROUP BY ਤੋਂ ਪਹਿਲਾਂ HAVING ਜਾਂ GROUP BY ਤੋਂ ਬਾਅਦ WHERE ਰੱਖਦੇ ਹੋ, ਤਾਂ ਵੈਲੀਡੇਟਰ ਤੁਹਾਨੂੰ ਚੇਤਾਵਨੀ ਦਿੰਦਾ ਹੈ। ਇਹ ISO/IEC 9075 SQL ਮਾਨਕ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ SQL ਮਾਨਕ ਸਿੰਟੈਕਸ ਨਿਯਮਾਂ ਦਾ ਪਾਲਨ ਕਰਦਾ ਹੈ।

ਤਰਕ ਸੰਬੰਧੀ ਗਲਤੀਆਂ

ON ਸ਼ਰਤਾਂ ਤੋਂ ਬਿਨਾਂ JOIN ਕਲਾਜ਼ ਅਣਚਾਹੇ ਕਰਾਸ ਜੋਇਨ ਬਣਾਉਂਦੇ ਹਨ, ਜੋ ਇਰਾਦੇ ਤੋਂ ਬਹੁਤ ਵੱਧ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਇੱਕ ਆਮ ਸਥਿਤੀ: ਤੁਸੀਂ ਕਵੇਰੀ ਵਿੱਚ ਤੀਜਾ ਜਾਂ ਚੌਥਾ ਟੇਬਲ ਜੋੜ ਰਹੇ ਹੋ ਅਤੇ ON ਕਲਾਜ਼ ਭੁੱਲ ਜਾਂਦੇ ਹੋ। ਇਸ ਜਾਂਚ ਤੋਂ ਬਿਨਾਂ, ਤੁਸੀਂ ਤਦ ਤੱਕ ਨਹੀਂ ਵੇਖ ਸਕੋਗੇ ਜਦ ਤੱਕ ਤੁਹਾਡੇ ਨਤੀਜਿਆਂ ਵਿੱਚ ਹਜ਼ਾਰਾਂ ਡੁਪਲੀਕੇਟ ਕਤਾਰਾਂ ਨਾ ਦਿਖਾਈ ਦੇਣ।

GROUP BY ਤੋਂ ਬਿਨਾਂ HAVING ਅਧਿਕਾਂਸ ਡੇਟਾਬੇਸ ਵਿੱਚ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਅਵੈਧ SQL ਹੈ। HAVING ਕਲਾਜ਼ ਗਰੁੱਪ ਕੀਤੇ ਗਏ ਨਤੀਜਿਆਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਕੰਮ ਕਰਨ ਲਈ GROUP BY ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਵੈਲੀਡੇਟਰ ਇਸ ਤਰਕ ਦੇ ਬੇਮੇਲ ਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ।

ਅਧੂਰੀਆਂ WHERE ਸ਼ਰਤਾਂ ਤਦ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਸ਼ਰਤ ਟਾਈਪ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੇ ਹੋ ਪਰ ਇਸ ਨੂੰ ਪੂਰਾ ਨਹੀਂ ਕਰਦੇ—ਜਿਵੇਂ ਕਿ ਕੋਈ ਮੁੱਲ ਨਾ ਦਿੰਦੇ ਹੋਏ WHERE status =। ਇਹ ਕਵੇਰੀਆਂ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਦੇ ਸਮੇਂ ਫਿਸਲ ਜਾਣ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਹਨ।

ਇਹ ਕੀ ਨਹੀਂ ਫੜ ਸਕਦਾ

ਇਹ ਵੈਲੀਡੇਟਰ ਸਿੰਟੈਕਸ ਅਤੇ ਸਟਰਕਚਰ 'ਤੇ ਕੇਂਦਰਿਤ ਹੈ, ਡੇਟਾਬੇਸ ਸਕੀਮਾ 'ਤੇ ਨਹੀਂ। ਇਹ ਨਹੀਂ ਜਾਣ ਸਕਦਾ ਕਿ:

ਤੁਹਾਡੇ ਟੇਬਲ ਜਾਂ ਕਾਲਮ ਦੇ ਨਾਂ ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਮੌਜੂਦ ਹਨ
ਤੁਸੀਂ ਅਨੁਕੂਲ ਡੇਟਾ ਟਾਈਪਾਂ 'ਤੇ ਜੋੜ ਰਹੇ ਹੋ
ਤੁਹਾਡੀ ਕਵੇਰੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰੇਗੀ ਜਾਂ ਇਸ ਵਿੱਚ ਅਨੁਕੂਲਨ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਹਨ
ਤੁਹਾਡੇ ਕੋਲ ਤੁਸੀਂ ਜਿਨ੍ਹਾਂ ਟੇਬਲਾਂ ਨੂੰ ਕਵੇਰੀ ਕਰ ਰਹੇ ਹੋ ਉਨ੍ਹਾਂ ਤੱਕ ਪਹੁੰਚ ਦੀ ਅਨੁਮਤ

ਫਾਰਮੈਟਿੰਗ ਨਿਯਮ ਜੋ ਇਸ ਟੂਲ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ

ਫਾਰਮੈਟਰ SQL ਸਟਾਈਲ ਗਾਈਡ ਕਨਵੈਨਸ਼ਨਾਂ ਦੇ ਅਧਾਰ 'ਤੇ ਲਗਾਤਾਰ ਨਿਯਮ ਲਾਗੂ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਬਹੁਤੇ ਡੇਟਾਬੇਸ ਟੀਮਾਂ ਪਾਲਣ ਕਰਦੀਆਂ ਹਨ।

ਕੀਵਰਡ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਲਿਖੇ ਜਾਂਦੇ ਹਨ

ਹਰ SQL ਕੀਵਰਡ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ: SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP। ਇਸ ਵਿੱਚ ਕਲਾਜ਼ (FROM, WHERE, GROUP BY, HAVING, ORDER BY), ਜੋਇਨ ਟਾਈਪ (JOIN, INNER JOIN, LEFT JOIN), ਆਪਰੇਟਰ (AND, OR, NOT, IN, BETWEEN, LIKE), ਅਤੇ ਆਮ ਫੰਕਸ਼ਨ (COUNT, SUM, AVG, CASE, WHEN) ਸ਼ਾਮਲ ਹਨ।

ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਕਿਉਂ? ਇਹ SQL ਦੇ ਭਾਸ਼ਾ ਤੱਤਾਂ ਅਤੇ ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ-ਵਿਸ਼ੇਸ਼ ਨਾਮਾਂ (ਟੇਬਲ, ਕਾਲਮ, ਅਲਾਇਆਸ) ਵਿਚਕਾਰ ਦਿ੍ਸ਼ਟੀਗਤ ਭੇਦ ਬਣਾਉਂਦਾ ਹੈ। ਇੱਕ ਕਵੇਰੀ ਨੂੰ ਸਕੈਨ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਡੀ ਅੱਖ ਤੁਰੰਤ ਸਟਰਕਚਰ ਨੂੰ ਪਕੜ ਲੈਂਦੀ ਹੈ।

ਹਰ ਲੈਵਲ 'ਤੇ ਦੋ-ਸਪੇਸ ਇੰਡੈਂਟੇਸ਼ਨ

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

ਕਾਮਾ-ਵੱਖ ਕੀਤੀਆਂ ਸੂਚੀਆਂ (ਉਦਾਹਰਨ ਲਈ SELECT ਵਿੱਚ ਕਾਲਮ ਨਾਮ) ਹਰ ਲਾਈਨ 'ਤੇ ਲਗਾਤਾਰ ਇੰਡੈਂਟੇਸ਼ਨ ਦੇ ਨਾਲ ਹੁੰਦੀਆਂ ਹਨ। ਜਦੋਂ ਤੁਹਾਡੀ SELECT ਸੂਚੀ ਵਿੱਚ 15 ਕਾਲਮ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਇਹ ਵਿਸ਼ੇਸ਼ ਕਾਲਮਾਂ ਨੂੰ ਸਕੈਨ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।

WHERE ਕਲਾਜ਼ ਵਿੱਚ ਸ਼ਰਤਾਂ ਲੰਬਵਤ ਤੌਰ 'ਤੇ ਇਕੱਠੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਕਈ AND ਜਾਂ OR ਸ਼ਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਇਕਸਾਰਤਾ ਤਰਕ ਦੀ ਸਟਰਕਚਰ ਨੂੰ ਤੁਰੰਤ ਸਪੱਸ਼ਟ ਕਰਦੀ ਹੈ।

ਫਾਰਮੈਟਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ: ਅੰਤਰ ਵੇਖੋ

ਫਾਰਮੈਟਿੰਗ ਤੋਂ ਪਹਿਲਾਂ:

1select u.id, u.name, o.order_date from users u join orders o on u.id = o.user_id where o.status = "completed" group by u.id order by u.name;
2

ਫਾਰਮੈਟਿੰਗ ਤੋਂ ਬਾਅਦ:

1SELECT
2  u.id,
3  u.name,
4  o.order_date
5FROM users u
6  JOIN orders o ON u.id = o.user_id
7WHERE
8  o.status = "completed"
9GROUP BY
10  u.id
11ORDER BY
12  u.name;
13

ਵੈਲੀਡੇਸ਼ਨ ਨਿਯਮ: ਕੀ ਫਲੈਗ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

ਵੈਲੀਡੇਟਰ ਸਟਰਕਚਰਲ ਇੰਟੈਗਰਿਟੀ ਅਤੇ ਬੁਨਿਆਦੀ ਤਰਕਸ਼ੀਲ ਸਾਂਝਗੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਉਹ ਕੀ ਵੇਖਦਾ ਹੈ:

ਸਟਰਕਚਰਲ ਜਾਂਚਾਂ

ਸੰਤੁਲਿਤ ਬਰੈਕਟ: ਖੋਲਣ ਅਤੇ ਬੰਦ ਕਰਨ ਵਾਲੇ ਬਰੈਕਟ ਮੇਲ ਖਾਣੇ ਚਾਹੀਦੇ ਹਨ। ਨੈਸਟਡ ਸਬ-ਕਵੇਰੀਆਂ ਵਿੱਚ ਅਕਸਰ ਬਰੈਕਟ ਦੇ ਕਈ ਪੱਧਰ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਗਿਣਤੀ ਗਲਤ ਕਰਨਾ SQL ਦੀਆਂ ਸਭ ਤੋਂ ਆਮ ਗਲਤੀਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਵੈਲੀਡੇਟਰ ਉਨ੍ਹਾਂ ਨੂੰ ਤੁਹਾਡੇ ਲਈ ਗਿਣਦਾ ਹੈ।

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

ਸਹੀ ਕਲੌਜ ਆਰਡਰ: SQL ਦੀਆਂ ਵਿਸ਼ੇਸ਼ ਆਰਡਰਿੰਗ ਲੋੜਾਂ ਹਨ। SELECT FROM ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ, ਜੋ WHERE ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ, ਜੋ GROUP BY ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ, ਜੋ HAVING ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ, ਜੋ ORDER BY ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ। ਉਨ੍ਹਾਂ ਨੂੰ ਅਕ੍ਰਮ ਵਿੱਚ ਰੱਖਣ ਨਾਲ ਤੁਰੰਤ ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਵੈਲੀਡੇਟਰ SQL ਮਾਨਕ ਦੇ ਅਧਾਰ 'ਤੇ ਇਸ ਆਰਡਰਿੰਗ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।

ਤਰਕਸ਼ੀਲ ਸਾਂਝਗੀ ਜਾਂਚਾਂ

ON ਸ਼ਰਤ ਦੇ ਨਾਲ JOIN: ਹਰ JOIN ਨੂੰ ਇੱਕ ON ਜਾਂ USING ਕਲੌਜ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੋ ਟੇਬਲਾਂ ਦੇ ਸਬੰਧ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਿਨਾਂ, ਤੁਹਾਨੂੰ ਇੱਕ ਕ੍ਰਾਸ ਜੋਇਨ ਮਿਲਦਾ ਹੈ—ਇੱਕ ਟੇਬਲ ਤੋਂ ਹਰ ਪੰਗਤੀ ਨੂੰ ਦੂਜੇ ਟੇਬਲ ਦੀ ਹਰ ਪੰਗਤੀ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਘੱਟ ਹੀ ਉਹ ਹੁੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਗੁੰਮ ਹੋਏ ON ਕਲੌਜ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਪੂਰੀ WHERE ਸ਼ਰਤਾਂ: WHERE ਕਲੌਜ ਨੂੰ ਪੂਰੀਆਂ ਪ੍ਰੀਡੀਕੇਟਸ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਬਿਨਾਂ ਮੁੱਲ ਦੇ WHERE status = ਅਧੂਰਾ ਅਤੇ ਅਵੈਧ ਹੈ। ਵੈਲੀਡੇਟਰ ਇਨ੍ਹਾਂ ਅਧੂਰੀਆਂ ਸ਼ਰਤਾਂ ਨੂੰ ਫਲੈਗ ਕਰਦਾ ਹੈ।

HAVING ਲਈ GROUP BY ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ: HAVING ਕਲੌਜ ਗਰੁੱਪ ਕੀਤੇ ਗਏ ਨਤੀਜਿਆਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਿਰਫ ਤਦ ਹੀ ਅਰਥ ਰੱਖਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ GROUP BY ਹੋਵੇ। HAVING ਦਾ GROUP BY ਤੋਂ ਬਿਨਾਂ ਉਪਯੋਗ ਕਰਨਾ ਇੱਕ ਤਰਕਸ਼ੀਲ ਗਲਤੀ ਹੈ ਜਿਸ ਨੂੰ ਜਿਆਦਾਤਰ ਡੇਟਾਬੇਸ ਅਸਵੀਕਾਰ ਕਰ ਦਿੰਦੇ ਹਨ।

GROUP BY ਏਗਰੀਗੇਸ਼ਨ ਨਿਯਮ: ਜਦੋਂ ਤੁਸੀਂ COUNT() ਜਾਂ SUM() ਵਰਗੀਆਂ ਏਗਰੀਗੇਟ ਫੰਕਸ਼ਨਾਂ ਦਾ ਉਪਯੋਗ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੀ SELECT ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਵੀ ਗੈਰ-ਏਗਰੀਗੇਟ ਕਾਲਮ ਨੂੰ GROUP BY ਵਿੱਚ ਦਿਖਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਇੱਕ ਮੂਲ SQL ਲੋੜ ਹੈ ਜਿਸ ਦੀ ਵੈਲੀਡੇਟਰ ਜਾਂਚ ਕਰਦਾ ਹੈ।

ਆਮ ਗਲਤੀਆਂ ਦਾ ਉਦਾਹਰਣ ਜੋ ਫੜੀਆਂ ਗਈਆਂ

ਇੱਥੇ SQL ਹੈ ਜਿਸ ਵਿੱਚ ਕਈ ਸਮੱਸਿਆਵਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਵੈਲੀਡੇਟਰ ਫਲੈਗ ਕਰੇਗਾ:

1SELECT user_id, COUNT(*) FROM orders
2JOIN users
3WHERE status =
4GROUP BY
5HAVING count > 10;
6

ਪਛਾਣੀਆਂ ਗਈਆਂ ਸਮੱਸਿਆਵਾਂ:

JOIN users ਵਿੱਚ ON ਸ਼ਰਤ ਗੁੰਮ ਹੈ (ਕ੍ਰਾਸ ਜੋਇਨ ਬਣਾਏਗਾ)
WHERE status = ਅਧੂਰਾ (ਤੁਲਨਾ ਦਾ ਕੋਈ ਮੁੱਲ ਨਹੀਂ)
ਖਾਲੀ GROUP BY ਕਲੌਜ (ਕੋਈ ਕਾਲਮ ਨਿਰਧਾਰਤ ਨਹੀਂ)
HAVING count > 10 ਅਪਰਿਭਾਸ਼ਿਤ ਕਾ

ਇਸ SQL ਫਾਰਮੈਟਰ ਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਹੈ

ਕੋਡ ਸਮੀਖਿਆਵਾਂ ਦੌਰਾਨ

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

ਡੇਟਾਬੇਸ ਬਦਲਾਵਾਂ ਵਾਲੀਆਂ ਪੁਲ ਰੀਕਵੈਸਟਾਂ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਸਮੇਂ, ਯੋਗਦਾਨ ਕਰਨ ਵਾਲਿਆਂ ਤੋਂ ਪਹਿਲਾਂ ਉਨ੍ਹਾਂ ਦੇ SQL ਨੂੰ ਫਾਰਮੈਟ ਕਰਨ ਲਈ ਕਹੋ। ਇਹ ਤਰਕ ਸੰਬੰਧੀ ਗਲਤੀਆਂ ਨੂੰ ਵੇਖਣਾ ਬਹੁਤ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ ਜਦੋਂ ਸਟਰਕਚਰ ਸੰਗਤ ਹੁੰਦਾ ਹੈ।

ਉਤਪਾਦਨ ਸਮੱਸਿਆਵਾਂ ਦਾ ਡੀਬੱਗ ਕਰਨਾ

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

ਆਪਣੇ ਲੌਗਾਂ ਤੋਂ ਕਵੇਰੀ ਕਾਪੀ ਕਰੋ, ਇੱਥੇ ਪੇਸਟ ਕਰੋ, ਅਤੇ ਤੁਰੰਤ ਦੇਖ ਸਕੋਗੇ ਕਿ ਕੀ ਸਟਰਕਚਰਲ ਸਮੱਸਿਆਵਾਂ ਹਨ।

ਉਤਪੰਨ SQL ਨਾਲ ਕੰਮ ਕਰਨਾ

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

SQL ਸਿਖਾਉਣਾ ਅਤੇ ਸਿੱਖਣਾ

ਜੇ ਤੁਸੀਂ SQL ਸਿੱਖ ਰਹੇ ਹੋ ਜਾਂ ਇਸਨੂੰ ਸਿਖਾ ਰਹੇ ਹੋ, ਇਹ ਫਾਰਮੈਟਰ ਤੁਹਾਨੂੰ ਸਹੀ ਕਵੇਰੀ ਸਟਰਕਚਰ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲੀ ਕਵੇਰੀ ਪੇਸਟ ਕਰਦੇ ਹੋ ਅਤੇ ਦੇਖਦੇ ਹੋ ਕਿ ਇਹ ਕਿਵੇਂ ਫਾਰਮੈਟ ਹੁੰਦੀ ਹੈ, ਤੁਸੀਂ ਨਿਯਮਾਂ ਨੂੰ ਸਿੱਖਦੇ ਹੋ। ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਟੁੱਟੀ ਹੋਈ ਕਵੇਰੀ ਪੇਸਟ ਕਰਦੇ ਹੋ ਅਤੇ ਵਾਲੀਡੇਸ਼ਨ ਗਲਤੀਆਂ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤੁਸੀਂ ਸਮਝਦੇ ਹੋ ਕਿ ਇਹ ਕਿਉਂ ਕੰਮ ਨਹੀਂ ਕਰਦੀ।

ਡੇਟਾਬੇਸ ਸਿਸਟਮਾਂ ਵਿੱਚ ਸਥਾਨਾਂਤਰਣ

ਵੱਖ-ਵੱਖ ਡੇਟਾਬੇਸ (ਪੋਸਟਗਰੇਸਕਿਊਐਲ, ਮਾਈਐਸਕਿਊਐਲ, SQL ਸਰਵਰ) ਦੇ ਥੋੜ੍ਹੇ ਵੱਖਰੇ SQL ਬੋਲੀ ਹਨ। ਸਿਸਟਮਾਂ ਵਿਚਕਾਰ ਕਵੇਰੀਆਂ ਨੂੰ ਸਥਾਨਾਂਤਰਿਤ ਕਰਦੇ ਸਮੇਂ, ਸਹੀ ਫਾਰਮੈਟਿੰਗ ਤੁਹਾਨੂੰ ਬੋਲੀ-ਵਿਸ਼ੇਸ਼ ਸਿੰਟੈਕਸ ਨੂੰ ਵੇਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਸਮਾਯੋਜਨ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ। ਫਾਰਮੈਟਰ ਮਾਨਕ SQL ਨਿਯਮਾਂ ਦਾ ਪਾਲਣ ਕਰਦਾ ਹੈ ਜੋ ਵੱਡੇ ਬਹੁਤੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹਨ।

SQL ਫਾਰਮੈਟਰ ਦੇ ਵਿਕਲਪ

ਡੇਟਾਬੇਸ-ਵਿਸ਼ੇਸ਼ IDE

DataGrip, SQL ਸਰਵਰ ਮੈਨੇਜਮੈਂਟ ਸਟੂਡੀਓ, ਜਾਂ MySQL ਵਰਕਬੈਂਚ ਵਰਗੇ ਟੂਲ ਵਿੱਚ ਬਿਲਟ-ਇਨ ਫਾਰਮੈਟਰ ਹੁੰਦੇ ਹਨ। ਇਹ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਕਨੈਕਸ਼ਨਾਂ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਹੁੰਦੇ ਹਨ।

ਵਿਚਾਰ: ਇਨ੍ਹਾਂ ਨੂੰ ਇੰਸਟਾਲ ਅਤੇ ਸੈਟਅੱਪ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। DataGrip ਵਿਅਕਤੀਗਤ ਉਪਯੋਗਕਰਤਾਵਾਂ ਲਈ $199/ਸਾਲ ਦਾ ਹੈ। SSMS ਮੁਫਤ ਹੈ ਪਰ ਸਿਰਫ Windows ਲਈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਬਿਨਾਂ ਕੁਝ ਇੰਸਟਾਲ ਕੀਤੇ ਤੁਰੰਤ ਫਾਰਮੈਟਿੰਗ ਦੀ ਲੋੜ ਹੈ, ਜਾਂ ਤੁਸੀਂ ਕਈ ਡੇਟਾਬੇਸ ਸਿਸਟਮਾਂ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਬਰਾਊਜ਼ਰ-ਅਧਾਰਿਤ ਟੂਲ ਵਧੇਰੇ ਵਿਵਹਾਰਕ ਹੈ।

ਐਡੀਟਰ ਐਕਸਟੈਨਸ਼ਨ

ਜੇਕਰ ਤੁਸੀਂ VS Code ਜਾਂ Sublime Text ਵਿੱਚ SQL ਲਿਖਦੇ ਹੋ, ਤਾਂ SQL Beautify ਜਾਂ SqlBeautifier ਵਰਗੀਆਂ ਐਕਸਟੈਨਸ਼ਨ ਤੁਹਾਡੇ ਐਡੀਟਰ ਵਿੱਚ ਫਾਰਮੈਟਿੰਗ ਲਿਆਉਂਦੀਆਂ ਹਨ। ਇਹ ਤਦ ਚੰਗਾ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਸਰਗਰਮ ਤੌਰ 'ਤੇ ਕਿਊਰੀਆਂ ਲਿਖ ਰਹੇ ਹੋ ਅਤੇ ਆਪਣੀ ਕਾਰਜ ਪ੍ਰਕਿਰਿਆ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਤੁਰੰਤ ਫਾਰਮੈਟਿੰਗ ਚਾਹੁੰਦੇ ਹੋ।

ਸੀਮਾ: ਐਕਸਟੈਨਸ਼ਨ ਨੂੰ ਕੌਨਫਿਗਰ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਇਹ ਤੁਹਾਡੇ ਵਿਸ਼ੇਸ਼ ਐਡੀਟਰ ਨਾਲ ਜੁੜੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਜਦੋਂ SQL ਨੂੰ ਟੀਮ ਦੇ ਮੈਂਬਰਾਂ ਨਾਲ ਸਾਂਝਾ ਕਰਦੇ ਹੋ ਜਾਂ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਵਿੱਚ ਕਿਊਰੀਆਂ ਪੋਸਟ ਕਰਦੇ ਹੋ, ਇੱਕ ਮਾਨਕ ਵੈੱਬ ਫਾਰਮੈਟਰ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਹਰ ਕੋਈ ਇੱਕੋ ਜਿਹਾ ਫਾਰਮੈਟਿੰਗ ਵੇਖੇ।

ਕਮਾਂਡ-ਲਾਈਨ ਫਾਰਮੈਟਰ

sqlformat (Python) ਜਾਂ sql-formatter-cli (Node.js) ਵਰਗੇ ਟੂਲ CI/CD ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਏਕੀਕ੍ਰਿਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ ਤਾਂ ਜੋ ਵਰਜਨ ਕੰਟਰੋਲ ਵਿੱਚ SQL ਨੂੰ ਆਪਣੇ ਆਪ ਫਾਰਮੈਟ ਕੀਤਾ ਜਾ ਸਕੇ। ਇਹ ਇੱਕ ਟੀਮ ਵਿੱਚ ਸਥਿਰਤਾ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।

ਸਵੈਚਾਲਿਤ ਵਰਕਫਲੋ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਬਜਾਏ ਤਤਕਾਲ ਫਾਰਮੈਟਿੰਗ ਦੇ। ਜੇਕਰ ਤੁਸੀਂ ਬੱਸ ਕੁਝ ਕਿਊਰੀਆਂ ਨੂੰ ਸਾਫ਼ ਕਰ ਰਹੇ ਹੋ ਜਾਂ SQL ਸਿੱਖ ਰਹੇ ਹੋ, ਤਾਂ ਕਮਾਂਡ-ਲਾਈਨ ਟੂਲ ਅਨਾਵਸ਼ਯਕ ਜਟਿਲਤਾ ਜੋੜਦੇ ਹਨ।

ਕਿਵੇਂ SQL ਫਾਰਮੈਟਿੰਗ ਮਾਨਕ ਅਭਿਆਸ ਬਣਿਆ

SQL ਦਾ ਵਿਕਾਸ 1970 ਦੇ ਦਹਾਕੇ ਵਿੱਚ IBM ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ ਫਾਰਮੈਟਿੰਗ ਨਿਯਮ ਬਹੁਤ ਬਾਅਦ ਵਿੱਚ ਆਏ। ਸ਼ੁਰੂਆਤੀ SQL ਕਾਰਜਸ਼ੀਲ ਸੀ ਪਰ ਅਨਿਯਮਤ—ਹਰੇਕ ਡਿਵੈਲਪਰ ਕਵੇਰੀਆਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਤਰੀਕੇ ਨਾਲ ਫਾਰਮੈਟ ਕਰਦਾ ਸੀ।

ਮੋੜ 1990 ਦੇ ਦਹਾਕੇ ਵਿੱਚ ਆਇਆ ਜਦੋਂ ਡਾਟਾਬੇਸ ਇੱਕ ਡਿਵੈਲਪਰ ਦੀਆਂ ਪਰਿਯੋਜਨਾਵਾਂ ਤੋਂ ਟੀਮ-ਅਧਾਰਿਤ ਵਿਕਾਸ ਵੱਲ ਵਧੇ। ਸੰਗਠਨਾਂ ਨੇ ਸਥਿਰਤਾ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਆਂਤਰਿਕ SQL ਸਟਾਈਲ ਗਾਈਡਾਂ ਬਣਾਉਣਾ ਸ਼ੁਰੂ ਕੀਤਾ। ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਹੀ ਡਾਟਾਬੇਸ 'ਤੇ ਕੰਮ ਕਰਦੇ ਪੰਜ ਡਿਵੈਲਪਰ ਸਨ, ਤਾਂ ਪੜ੍ਹਨ ਯੋਗ SQL ਸਹਿਯੋਗ ਲਈ ਜ਼ਰੂਰੀ ਹੋ ਗਿਆ।

2000 ਦੇ ਦਹਾਕੇ ਵਿੱਚ ORMs ਆਏ ਜਿਨ੍ਹਾਂ ਨੇ SQL ਨੂੰ ਆਪਣੇ-ਆਪ ਤਿਆਰ ਕੀਤਾ। ਇਨ੍ਹਾਂ ਟੂਲਾਂ ਨੇ ਕੰਮ ਕਰਨ ਵਾਲਾ ਪਰ ਬਦਸੂਰਤ SQL ਤਿਆਰ ਕੀਤਾ—ਸਭ ਕੁਝ ਇੱਕ ਲਾਈਨ 'ਤੇ, ਕੋਈ ਇੰਡੈਂਟੇਸ਼ਨ ਨਹੀਂ। ਇਸ ਨੇ ਆਟੋਮੇਟਿਡ ਫਾਰਮੈਟਰਾਂ ਲਈ ਮੰਗ ਪੈਦਾ ਕੀਤੀ ਜੋ ਤਿਆਰ ਕੀਤੇ ਗਏ SQL ਨੂੰ ਮਨੁੱਖ ਲਈ ਪੜ੍ਹਨ ਯੋਗ ਬਣਾ ਸਕਣ।

2010 ਦੇ ਦਹਾਕੇ ਵਿੱਚ ਵੈਬ ਵਿਕਾਸ ਪੱਕਿਆ ਤਾਂ ਆਨਲਾਈਨ SQL ਫਾਰਮੈਟਰ ਆਏ। ਟੂਲ ਇੰਸਟਾਲ ਕਰਨ ਜਾਂ IDE ਪਲੱਗਇਨ ਕੌਨਫਿਗਰ ਕਰਨ ਦੀ ਬਜਾਏ, ਡਿਵੈਲਪਰ SQL ਨੂੰ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰ ਸਕਦੇ ਸਨ। ਇਸ ਨੇ SQL ਸਿੱਖਣ ਵਾਲੇ ਸ਼ੁਰੂਆਤੀ ਤੋਂ ਲੈ ਕੇ ਤਜਰਬੇਕਾਰ ਡਿਵੈਲਪਰਾਂ ਤੱਕ ਸਭ ਲਈ ਸਹੀ ਫਾਰਮੈਟਿੰਗ ਤੱਕ ਪਹੁੰਚ ਨੂੰ ਲੋਕਤੰਤਰਿਕ ਬਣਾ ਦਿੱਤਾ।

ਅੱਜ, SQL ਫਾਰਮੈਟਿੰਗ ਨੂੰ ਇੱਕ ਬੇਸਲਾਈਨ ਅਭਿਆਸ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਪਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਕੋਡ ਫਾਰਮੈਟਿੰਗ ਦੇ ਸਮਾਨ। Simon Holywell ਦੀ SQL ਸਟਾਈਲ ਗਾਈਡ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਅਪਣਾਈਆਂ ਗਈਆਂ ਪਰੰਪਰਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਟੂਲ ਉਨ੍ਹਾਂ ਮਾਨਕਾਂ ਨੂੰ ਆਪਣੇ-ਆਪ ਲਾਗੂ ਕਰਦੇ ਹਨ।

ਕੋਡ ਉਦਾਹਰਣਾਂ

ਉਦਾਹਰਣ 1: ਬੁਨਿਆਦੀ SELECT ਕਵੇਰੀ

ਬਿਨਾਂ ਫਾਰਮੈਟ ਦੇ:

1select id, first_name, last_name, email from customers where status = 'active' order by last_name, first_name;
2

ਫਾਰਮੈਟ ਕੀਤਾ ਹੋਇਆ:

1SELECT
2  id,
3  first_name,
4  last_name,
5  email
6FROM
7  customers
8WHERE
9  status = 'active'
10ORDER BY
11  last_name,
12  first_name;
13

ਉਦਾਹਰਣ 2: JOIN ਕਵੇਰੀ

ਬਿਨਾਂ ਫਾਰਮੈਟ ਦੇ:

1select c.id, c.name, o.order_date, o.total_amount from customers c left join orders o on c.id = o.customer_id where o.order_date >= '2023-01-01' and o.status != 'cancelled' order by o.order_date desc;
2

ਫਾਰਮੈਟ ਕੀਤਾ ਹੋਇਆ:

1SELECT
2  c.id,
3  c.name,
4  o.order_date,
5  o.total_amount
6FROM
7  customers c
8  LEFT JOIN orders o ON c.id = o.customer_id
9WHERE
10  o.order_date >= '2023-01-01'
11  AND o.status != 'cancelled'
12ORDER BY
13  o.order_date DESC;
14

ਉਦਾਹਰਣ 3: ਜਟਿਲ ਕਵੇਰੀ ਸਬ-ਕਵੇਰੀ ਦੇ ਨਾਲ

ਬਿਨਾਂ ਫਾਰਮੈਟ ਦੇ:

1select d.department_name, (select count(*) from employees e where e.department_id = d.id) as employee_count, (select avg(salary) from employees e where e.department_id = d.id) as avg_salary from departments d where d.active = true having employee_count > 0 order by avg_salary desc;
2

ਫਾਰਮੈਟ ਕੀਤਾ ਹੋਇਆ:

1SELECT
2  d.department_name,
3  (
4    SELECT
5      COUNT(*)
6    FROM
7      employees e
8    WHERE
9      e.department_id = d.id
10  ) AS employee_count,
11  (
12    SELECT
13      AVG(salary)
14    FROM
15      employees e
16    WHERE
17      e.department_id = d.id
18  ) AS avg_salary
19FROM
20  departments d
21WHERE
22  d.active = TRUE
23HAVING
24  employee_count > 0
25ORDER BY
26  avg_salary DESC;
27

ਪ੍ਰੋਗਰਾਮੇਟਿਕ SQL ਫਾਰਮੈਟਿੰਗ

ਇੱਥੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ SQL ਫਾਰਮੈਟਿੰਗ ਲਾਗੂ ਕਰਨ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਹਨ:

1// JavaScript SQL ਫਾਰਮੈਟਿੰਗ ਉਦਾਹਰਣ sql-formatter ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ
2const sqlFormatter = require('sql-formatter');
3
4function formatSQL(sql) {
5  return sqlFormatter.format(sql, {
6    language: 'sql',
7    uppercase: true,
8    linesBetweenQueries: 2,
9    indentStyle: 'standard'
10  });
11}
12
13const rawSQL = "select id, name from users where status='active'";
14const formattedSQL = formatSQL(rawSQL);
15console.log(formattedSQL);
16

1# Python SQL ਫਾਰਮੈਟਿੰਗ ਉਦਾਹਰਣ sqlparse ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ
2import sqlparse
3
4def format_sql(sql):
5    return sqlparse.format(
6        sql,
7        reindent=True,
8        keyword_case='upper',
9        identifier_case='lower',
10        indent_width=2
11    )
12
13raw_sql = "select id, name from users where status='active'"
14formatted_sql = format_sql(raw_sql)
15print(formatted_sql)
16

1// Java SQL ਫਾਰਮੈਟਿੰਗ ਉਦਾਹਰਣ JSqlParser ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ
2import net.sf.jsqlparser.parser.CCJSqlParserUtil;
3import net.sf.jsqlparser.statement.Statement;
4
5public class SQLFormatter {
6    public static String formatSQL(String sql) throws Exception {
7        Statement statement = CCJSqlParserUtil.parse(sql);
8        return statement.toString()
9            .replaceAll("(?i)SELECT", "\nSELECT")
10            .replaceAll("(?i)FROM", "\nFROM")
11            .replaceAll("(?i)WHERE", "\nWHERE")
12            .replaceAll("(?i)ORDER BY", "\nORDER BY");
13    }
14    
15    public static void main(String[] args) throws Exception {
16        String rawSQL = "select id, name from users where status='active'";
17        String formattedSQL = formatSQL(rawSQL);
18        System.out.println(formattedSQL);
19    }
20}
21

1<?php
2// PHP SQL ਫਾਰਮੈਟਿੰਗ ਉਦਾਹਰਣ
3function formatSQL($sql) {
4    // ਕੀਵਰਡਾਂ ਨੂੰ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲੋ
5    $keywords = ['SELECT', 'FROM', 'WHERE', 'JOIN', 'LEFT JOIN', 'RIGHT JOIN', 
6                 'INNER JOIN', 'GROUP BY', 'ORDER BY', 'HAVING', 'LIMIT'];
7    
8    $formattedSQL = $sql;
9    foreach ($keywords as $keyword) {
10        $formattedSQL = preg_replace('/\b' . preg_quote($keyword, '/') . '\b/i', "\n$keyword", $formattedSQL);
11    }
12    
13    // ਇੰਡੈਂਟੇਸ਼ਨ ਜੋੜੋ
14    $lines = explode("\n", $formattedSQL);
15    $result = '';
16    $indentLevel = 0;
17    
18    foreach ($lines as $line) {
19        $trimmedLine = trim($line);
20        if (!empty($trimmedLine)) {
21            $result .= str_repeat("  ", $indentLevel) . $trimmedLine . "\n";
22        }
23    }
24    
25    return $result;
26}
27
28$rawSQL = "select id, name from users where status='active'";
29$formattedSQL = formatSQL($rawSQL);
30echo $formattedSQL;
31?>
32

ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ

ਕੀ ਇਹ SQL ਫਾਰਮੈਟਰ PostgreSQL, MySQL ਅਤੇ SQL ਸਰਵਰ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ?

ਹਾਂ, ਇਹ ਮੁੱਖ ਡੇਟਾਬੇਸਾਂ ਵਿੱਚ ਆਮ SQL ਸਿਨਟੈਕਸ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ—PostgreSQL, MySQL, SQL ਸਰਵਰ (T-SQL), Oracle, SQLite, ਅਤੇ MariaDB। ਫਾਰਮੈਟਰ ਮੁੱਖ SQL 'ਤੇ ਕੇਂਦਰਤ ਹੈ ਜੋ ਹਰ ਥਾਂ ਕੰਮ ਕਰਦਾ ਹੈ: SELECT, JOIN, WHERE, GROUP BY, ਆਦਿ।

ਡੇਟਾਬੇਸ-ਵਿਸ਼ੇਸ਼ ਫੀਚਰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਫਾਰਮੈਟ ਨਾ ਹੋ ਸਕਣ। ਉਦਾਹਰਨ ਲਈ, PostgreSQL ਦੀ ਐਰੇ ਸਿਨਟੈਕਸ ਜਾਂ SQL ਸਰਵਰ ਦੇ ਵਿਸ਼ੇਸ਼ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵਿਸ਼ੇਸ਼ ਫਾਰਮੈਟਿੰਗ ਨਹੀਂ ਮਿਲ ਸਕਦੀ, ਪਰ ਇਹ ਫਾਰਮੈਟਰ ਨੂੰ ਨਹੀਂ ਤੋੜੇਗਾ। ਕਵੇਰੀ ਫਿਰ ਵੀ ਪਹਿਲੇ ਨਾਲੋਂ ਵਧੇਰੇ ਪੜ੍ਹਨਯੋਗ ਹੋਵੇਗੀ।

ਕੀ ਮੇਰਾ SQL ਕੋਡ ਸਰਵਰ 'ਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ?

ਨਹੀਂ। ਸਭ ਕੁਝ ਤੁਹਾਡੇ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। ਆਪਣਾ SQL ਪੇਸਟ ਕਰੋ, ਅਤੇ ਇਹ ਸਥਾਨਕ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਹੋ ਜਾਵੇਗਾ ਬਿਨਾਂ ਕਿਸੇ ਨੈੱਟਵਰਕ ਬੇਨਤੀ ਦੇ। ਤੁਹਾਡੀਆਂ ਕਵੇਰੀਆਂ ਕਦੇ ਵੀ ਤੁਹਾਡੀ ਮਸ਼ੀਨ ਤੋਂ ਬਾਹਰ ਨਹੀਂ ਜਾਂਦੀਆਂ।

ਇਹ ਉਦੋਂ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ ਸਕੀਮਾ ਜਾਂ ਗੁਪਤ ਕਾਰੋਬਾਰੀ ਤਰਕ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ। ਕਿਸੇ ਹੋਰ ਦੇ ਸਰਵਰ 'ਤੇ ਸੰਵੇਦਨਸ਼ੀਲ ਜਾਣਕਾਰੀ ਲੌਗ ਜਾਂ ਸਟੋਰ ਹੋਣ ਦਾ ਕੋਈ ਜੋਖਮ ਨਹੀਂ ਹੈ।

ਕੀ ਵੈਲੀਡੇਟਰ ਸਾਰੀਆਂ SQL ਗਲਤੀਆਂ ਨੂੰ ਫੜ ਸਕਦਾ ਹੈ?

ਬਿਲਕੁਲ ਨਹੀਂ। ਇਹ ਸਿਰਫ਼ ਢਾਂਚਾਗਤ ਅਤੇ ਸਿਨਟੈਕਸ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਫੜਦਾ ਹੈ—ਗੁੰਮ ਹੋਏ ਬਰੈਕਟ, ਬੰਦ ਨਾ ਹੋਏ ਕੋਟ, ਗਲਤ ਕ੍ਰਮ ਵਿੱਚ ਜ਼ੋਨ। ਬਸ ਇਹੀ।

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

(ਬਾਕੀ ਅਨੁਵਾਦ ਜਾਰੀ ਰਹੇਗਾ...)

ਹਵਾਲੇ ਅਤੇ ਹੋਰ ਪੜ੍ਹਾਈ

ਸਾਇਮਨ ਹੋਲੀਵੈੱਲ ਦਾ SQL ਸਟਾਈਲ ਗਾਈਡ - ਵਿਕਾਸ ਟੀਮਾਂ ਦੁਆਰਾ ਵਰਤੇ ਜਾਣ ਵਾਲੇ SQL ਫਾਰਮੈਟਿੰਗ ਨਿਯਮਾਂ ਲਈ ਡੀ ਫੈਕਟੋ ਮਾਨਕ
ISO/IEC 9075 SQL ਮਾਨਕ - SQL ਦੇ ਅਧਿਕਾਰਿਕ ਅੰਤਰਰਾਸ਼ਟਰੀ ਮਾਨਕ ਵਿਵਰਣ
PostgreSQL SQL ਸਿੰਟੈਕਸ ਦਸਤਾਵੇਜ਼ੀਕਰਨ - PostgreSQL ਦਾ ਵਿਆਪਕ SQL ਸਿੰਟੈਕਸ ਹਵਾਲਾ
ਮਾਈਕਰੋਸਾਫਟ T-SQL ਹਵਾਲਾ - SQL ਸਰਵਰ ਦੇ T-SQL ਬੋਲੀ ਲਈ ਅਧਿਕਾਰਿਕ ਦਸਤਾਵੇਜ਼ੀਕਰਨ
MySQL ਹਵਾਲਾ ਮੈਨੁਅਲ - MySQL ਦਾ ਪੂਰਾ SQL ਸਟੇਟਮੈਂਟ ਹਵਾਲਾ

ਆਪਣੇ SQL ਨੂੰ ਫਾਰਮੈਟ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੋ

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

SQL ਫਾਰਮੈਟਰ ਅਤੇ ਵੈਲੀਡੇਟਰ - ਆਨਲਾਈਨ ਮੁਫਤ SQL ਕਿਊਰੀਜ਼ ਫਾਰਮੈਟ ਕਰੋ

ਦਸਤਾਵੇਜ਼ੀਕਰਣ

ਕਿਉਂ SQL ਫਾਰਮੈਟਿੰਗ ਮਹੱਤਵਪੂਰਨ ਹੈ

SQL ਫਾਰਮੈਟਰ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

SQL ਫਾਰਮੈਟਰ ਕੀ ਕਰਦਾ ਹੈ

ਕੀਵਰਡ ਦੀ ਵੱਡੀ ਅੱਖਰ ਵਿੱਚ ਲਿਖਾਈ

ਸਮਾਰਟ ਇੰਡੈਂਟੇਸ਼ਨ

ਤਰਕ-ਸੰਗਤ ਲਾਈਨ ਬ੍ਰੇਕ

SQL ਵੈਲੀਡੇਸ਼ਨ: ਕੀ ਚੈੱਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

ਸਟਰਕਚਰਲ ਗਲਤੀਆਂ

ਤਰਕ ਸੰਬੰਧੀ ਗਲਤੀਆਂ

ਇਹ ਕੀ ਨਹੀਂ ਫੜ ਸਕਦਾ

ਫਾਰਮੈਟਿੰਗ ਨਿਯਮ ਜੋ ਇਸ ਟੂਲ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ

ਕੀਵਰਡ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਲਿਖੇ ਜਾਂਦੇ ਹਨ

ਹਰ ਲੈਵਲ 'ਤੇ ਦੋ-ਸਪੇਸ ਇੰਡੈਂਟੇਸ਼ਨ

ਫਾਰਮੈਟਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ: ਅੰਤਰ ਵੇਖੋ

ਵੈਲੀਡੇਸ਼ਨ ਨਿਯਮ: ਕੀ ਫਲੈਗ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

ਸਟਰਕਚਰਲ ਜਾਂਚਾਂ

ਤਰਕਸ਼ੀਲ ਸਾਂਝਗੀ ਜਾਂਚਾਂ

ਆਮ ਗਲਤੀਆਂ ਦਾ ਉਦਾਹਰਣ ਜੋ ਫੜੀਆਂ ਗਈਆਂ

ਇਸ SQL ਫਾਰਮੈਟਰ ਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਹੈ

ਕੋਡ ਸਮੀਖਿਆਵਾਂ ਦੌਰਾਨ

ਉਤਪਾਦਨ ਸਮੱਸਿਆਵਾਂ ਦਾ ਡੀਬੱਗ ਕਰਨਾ

ਉਤਪੰਨ SQL ਨਾਲ ਕੰਮ ਕਰਨਾ

SQL ਸਿਖਾਉਣਾ ਅਤੇ ਸਿੱਖਣਾ

ਡੇਟਾਬੇਸ ਸਿਸਟਮਾਂ ਵਿੱਚ ਸਥਾਨਾਂਤਰਣ

SQL ਫਾਰਮੈਟਰ ਦੇ ਵਿਕਲਪ

ਡੇਟਾਬੇਸ-ਵਿਸ਼ੇਸ਼ IDE

ਐਡੀਟਰ ਐਕਸਟੈਨਸ਼ਨ

ਕਮਾਂਡ-ਲਾਈਨ ਫਾਰਮੈਟਰ

ਕਿਵੇਂ SQL ਫਾਰਮੈਟਿੰਗ ਮਾਨਕ ਅਭਿਆਸ ਬਣਿਆ

ਕੋਡ ਉਦਾਹਰਣਾਂ

ਉਦਾਹਰਣ 1: ਬੁਨਿਆਦੀ SELECT ਕਵੇਰੀ

ਉਦਾਹਰਣ 2: JOIN ਕਵੇਰੀ

ਉਦਾਹਰਣ 3: ਜਟਿਲ ਕਵੇਰੀ ਸਬ-ਕਵੇਰੀ ਦੇ ਨਾਲ

ਪ੍ਰੋਗਰਾਮੇਟਿਕ SQL ਫਾਰਮੈਟਿੰਗ

ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ

ਕੀ ਇਹ SQL ਫਾਰਮੈਟਰ PostgreSQL, MySQL ਅਤੇ SQL ਸਰਵਰ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ?

ਕੀ ਮੇਰਾ SQL ਕੋਡ ਸਰਵਰ 'ਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ?

ਕੀ ਵੈਲੀਡੇਟਰ ਸਾਰੀਆਂ SQL ਗਲਤੀਆਂ ਨੂੰ ਫੜ ਸਕਦਾ ਹੈ?

ਹਵਾਲੇ ਅਤੇ ਹੋਰ ਪੜ੍ਹਾਈ

ਆਪਣੇ SQL ਨੂੰ ਫਾਰਮੈਟ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੋ