மீண்டும் மீண்டும்

Mia Chevalier

ஞாயிறு, 29 டிசம்பர், 2024 ’அன்று’ பிற்பகல் 8:00:35

திரும்பத் திரும்ப வரும் வரிசை எண்களுடன் நேர-தொடர் ஒருங்கிணைப்பு மாஸ்டரிங்

SQL நேர-தொடர் தரவுகளுடன் பணிபுரிவது தந்திரமானதாக மாறும், குறிப்பாக மீண்டும் மீண்டும் வரிசை எண்களைக் கையாளும் போது. நீங்கள் உற்பத்தித் தரவை நிர்வகிக்கிறீர்கள் மற்றும் நேரமுத்திரைகளை ஒன்றுடன் ஒன்று சேர்க்கும் போது எண்ணிக்கையை ஒருங்கிணைக்க வேண்டும் எனில், விரும்பிய முடிவை அடைய துல்லியமான வினவல் அமைப்பு தேவை. 😅

ஒவ்வொரு வரிசையும் உற்பத்தி சுழற்சியைக் குறிக்கும் அட்டவணை உங்களிடம் இருப்பதாக கற்பனை செய்து பாருங்கள். தொடர்ச்சியான நேர வரம்புகளைக் கண்காணிக்கும் போது, `ஆர்டர்_ஐடி` அடிப்படையில் மொத்த எண்ணிக்கையைச் செய்வதே உங்கள் பணி. `order_id` என்பது தனித்துவமாக இல்லாதபோது சவால் அதிகரிக்கிறது, தரவைச் சரியாகப் பிரித்துச் சுருக்கிக் கூறுவது அவசியமாகும்.

இந்தச் சிக்கலைத் திறம்படத் தீர்க்கும் வினவலை எவ்வாறு உருவாக்குவது என்பதை இந்தக் கட்டுரையில் ஆராய்வோம். ஒரு சிக்கலான SQL சூழ்நிலையை உடைப்பதன் மூலம், நேரத் தொடர் திரட்டலில் தனித்துவமான மற்றும் தனித்துவமான அடையாளங்காட்டிகளைக் கையாள படிப்படியான நுட்பங்களைக் கற்றுக்கொள்வீர்கள். 🛠️

நீங்கள் உற்பத்தி பணிப்பாய்வுகளைச் சரிசெய்தாலும் அல்லது உங்கள் SQL நிபுணத்துவத்தை மேம்படுத்தினாலும், உங்களுக்குத் தேவையான முடிவுகளைப் பெறுவதற்கான நடைமுறைக் கருவிகள் மற்றும் உத்திகளை இந்த வழிகாட்டி உங்களுக்கு வழங்கும். இந்த ஒருங்கிணைப்பு புதிரை ஒன்றாகத் தீர்ப்பதில் முழுக்கு போடுவோம்!

கட்டளை	பயன்பாட்டின் உதாரணம்
LAG()	இந்தச் சாளரச் செயல்பாடு, குறிப்பிட்ட வரிசையின் அடிப்படையில், அதே முடிவு தொகுப்பில் உள்ள முந்தைய வரிசையில் இருந்து ஒரு நெடுவரிசையின் மதிப்பை மீட்டெடுக்கிறது. ஆர்டர்_ஐடியில் மாற்றங்களைக் கண்டறிய இங்கே பயன்படுத்தப்படுகிறது.
LEAD()	முடிவு தொகுப்பில் அடுத்த வரிசையில் இருந்து ஒரு நெடுவரிசையின் மதிப்பைப் பெறும் ஒரு சாளர செயல்பாடு. இது வினவலில் ஆர்டர்_ஐடி மதிப்புகளுக்கு இடையிலான மாற்றங்களைக் கண்காணிக்க உதவுகிறது.
ROW_NUMBER()	வினவலில் காட்டப்பட்டுள்ளபடி, முடிவுத் தொகுப்பில் உள்ள ஒவ்வொரு வரிசைக்கும் ஒரு தனித்துவமான வரிசை எண்ணை உருவாக்குகிறது.
CASE	SQL இல் நிபந்தனை தர்க்கத்தை செயல்படுத்த பயன்படுகிறது. எடுத்துக்காட்டில், ஒரு புதிய ஆர்டர்_ஐடி தோன்றும் போது அது ஒரு தனிப்பட்ட குழுமக் கொடியை ஒதுக்குகிறது.
WITH (Common Table Expression)	முக்கிய வினவலில் குறிப்பிடக்கூடிய தற்காலிக முடிவு தொகுப்பை வரையறுக்கிறது. இது வரிசைகளுக்கு இடையிலான மாற்றங்களுக்கான தர்க்கத்தை எளிதாக்குகிறது.
CREATE TEMP TABLE	இடைநிலை முடிவுகளைச் சேமிக்க ஒரு தற்காலிக அட்டவணையை உருவாக்குகிறது. PL/pgSQL எடுத்துக்காட்டில் மேலும் செயலாக்கத்திற்கு ஒருங்கிணைக்கப்பட்ட தரவை வைத்திருக்க பயன்படுத்தப்படுகிறது.
FOR ... LOOP	PL/pgSQL இல் ஒரு செயல்முறை வளைய கட்டுமானம். தரவை மாறும் வகையில் செயலாக்க, உற்பத்தி அட்டவணையில் உள்ள வரிசைகள் மூலம் மீண்டும் மீண்டும் செய்கிறது.
client.query()	Node.js இன் pg லைப்ரரிக்கு குறிப்பிட்டது. PostgreSQL தரவுத்தளத்தில் SQL வினவலை இயக்கி, முடிவுகளை மாறும் வகையில் மீட்டெடுக்கிறது.
DO $$ ... END $$	சேமிக்கப்பட்ட செயல்முறையை உருவாக்காமல், PL/pgSQL ஸ்கிரிப்ட்கள் போன்ற நடைமுறைக் குறியீட்டின் தொகுதியைச் செயல்படுத்த PostgreSQL இல் பயன்படுத்தப்படுகிறது.
GROUP BY with aggregation	SUM, MIN மற்றும் MAX போன்ற ஒருங்கிணைக்கப்பட்ட மதிப்புகளைக் கணக்கிடும் போது, அதே ஆர்டர்_ஐடியுடன் வரிசைகளைக் குழுவாக்குவதன் மூலம் தரவைச் சுருக்கமாகக் கூறப் பயன்படுகிறது.

சிக்கலான நேர-தொடர் தரவுகளுக்கான SQL திரட்டலைப் புரிந்துகொள்வது

நேரத் தொடர் தரவுகளின் சூழலில் எங்கே ஆர்டர்_ஐடி மதிப்புகள் மீண்டும் மீண்டும் வருகின்றன, திரட்டல் சிக்கல்களைத் தீர்க்க மேம்பட்ட SQL அம்சங்களைப் பயன்படுத்த வேண்டும். எடுத்துக்காட்டாக, `LAG()` மற்றும் `LEAD()` செயல்பாடுகள் முந்தைய அல்லது அடுத்த வரிசை மதிப்புகளைக் குறிப்பிடுவதன் மூலம் வரிசைகளுக்கு இடையே உள்ள மாற்றங்களைக் கண்காணிக்க உதவுகின்றன. ஒரு புதிய குழு எப்போது தொடங்குகிறது என்பதை தீர்மானிக்க இது அனுமதிக்கிறது. ஆர்டர்கள் பெரும்பாலும் ஒன்றுடன் ஒன்று உற்பத்தி தரவு போன்ற காட்சிகளில் இந்த கட்டளைகள் குறிப்பாக உதவியாக இருக்கும். பல நேர வரம்புகளைக் கொண்ட ஆர்டர்களுக்கான மொத்தங்களைக் கணக்கிட முயற்சிப்பதை கற்பனை செய்து பாருங்கள் - இந்த அமைப்பு அந்த செயல்முறையை நிர்வகிக்கிறது. 😊

பயன்பாடு பொதுவான அட்டவணை வெளிப்பாடுகள் (CTEகள்) சிக்கலான வினவல்களை சிறிய, அதிக செரிமான பகுதிகளாக உடைப்பதன் மூலம் எளிதாக்குகிறது. `WITH` உட்பிரிவு ஒரு தற்காலிக முடிவுத் தொகுப்பை வரையறுக்கிறது, அதை அடுத்தடுத்த வினவல்களில் குறிப்பிடலாம். எங்களின் எடுத்துக்காட்டில், ஒரு புதிய `ஆர்டர்_ஐடி' எங்கிருந்து தொடங்குகிறது என்பதைக் கண்டறிந்து அதற்கேற்ப வரிசைகளைக் குழுவாக்க உதவுகிறது. இது நீளமான, உள்ளமைக்கப்பட்ட துணை வினவல்களை எழுத வேண்டிய தேவையைத் தவிர்க்கிறது, புதியவர்களுக்குக் கூட SQL ஐ எளிதாகப் படிக்கவும் பராமரிக்கவும் செய்கிறது.

நடைமுறை SQL எடுத்துக்காட்டில், PL/pgSQL ஆனது வரிசை-வரிசை செயலாக்கத்தை மாறும் வகையில் கையாள பயன்படுத்தப்படுகிறது. இடைநிலை கணக்கீடுகள் பாதுகாக்கப்படுவதை உறுதிசெய்யும் வகையில், ஒரு தற்காலிக அட்டவணை ஒருங்கிணைக்கப்பட்ட முடிவுகளைச் சேமிக்கிறது. தரவு முரண்பாடுகள் அல்லது இடைவெளிகளுக்கு கூடுதல் கைமுறை கையாளுதல் தேவைப்படும்போது இது மிகவும் சிக்கலான நிகழ்வுகளுக்கு பயனுள்ளதாக இருக்கும். நிஜ-உலக உற்பத்தி காட்சிகள் பெரும்பாலும் சரிசெய்தல்களை உள்ளடக்கியது, மேலும் மட்டு, மீண்டும் பயன்படுத்தக்கூடிய குறியீட்டைக் கொண்டிருப்பது டெவலப்பர்களுக்கு இதுபோன்ற சிக்கல்களை விரைவாகத் தீர்க்க உதவுகிறது. 🛠️

கடைசியாக, Node.js பின்தளத்தில் ஸ்கிரிப்ட் SQL ஐ எவ்வாறு செயலியாக பயன்பாடுகளில் ஒருங்கிணைக்க முடியும் என்பதை விளக்குகிறது. `pg` போன்ற நூலகங்களைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் தரவுத்தளங்களுடன் அளவிடக்கூடிய முறையில் தொடர்பு கொள்ளலாம். நிகழ்நேரத் தரவைச் செயலாக்கி காண்பிக்கும் இணையப் பயன்பாடுகளுக்கு இந்த அணுகுமுறை மிகவும் பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, உற்பத்திப் புள்ளிவிவரங்களைக் காட்டும் டாஷ்போர்டு இந்த வினவல்களை திரைக்குப் பின்னால் செயல்படுத்தி, புதுப்பித்த நுண்ணறிவுகளை வழங்கும். இந்த வளைந்து கொடுக்கும் தன்மை, தீர்வு சக்தி வாய்ந்தது மட்டுமல்ல, வெவ்வேறு சூழல்களுக்கும் பயன்பாட்டு நிகழ்வுகளுக்கும் ஏற்றதாக இருப்பதை உறுதி செய்கிறது.

தொடர்ச்சியான வரிசை எண்களுக்கான SQL உடன் நேர-தொடர் தரவை ஒருங்கிணைத்தல்

இந்த தீர்வு SQL ஐப் பயன்படுத்தி நேர-தொடர் திரட்டலுடன் தனித்தன்மையற்ற வரிசை எண்களைக் கையாளும் மட்டு வினவலை உருவாக்குகிறது.

-- Define a Common Table Expression (CTE) to track transitions between order IDs
WITH order_transitions AS (
    SELECT
        *,
        LAG(order_id) OVER (ORDER BY start) AS prev_id,
        LEAD(order_id) OVER (ORDER BY start) AS next_id
    FROM production
)
-- Create a query to handle gaps and the first line issue
SELECT
    order_id,
    MIN(start) AS start,
    MAX(end) AS end,
    SUM(count) AS total_count
FROM (
    SELECT
        order_id,
        start,
        end,
        count,
        CASE
            WHEN prev_id != order_id OR prev_id IS  THEN ROW_NUMBER() OVER (ORDER BY start)
            ELSE 
        END AS grouping_flag
    FROM order_transitions
) t
GROUP BY order_id, grouping_flag
ORDER BY start;

தனிப்பயன் திரட்டலுக்கு PL/pgSQL உடன் நடைமுறை SQL ஐப் பயன்படுத்துதல்

இந்த அணுகுமுறை PostgreSQL இல் PL/pgSQL ஐப் பயன்படுத்துகிறது.

DO $$
DECLARE
    curr_order_id INTEGER;
    curr_start TIMESTAMP;
    curr_end TIMESTAMP;
    curr_count INTEGER;
BEGIN
    -- Create a temp table to hold results
    CREATE TEMP TABLE aggregated_data (
        order_id INTEGER,
        start TIMESTAMP,
        end TIMESTAMP,
        count INTEGER
    );
    -- Loop through each row in production
    FOR row IN SELECT * FROM production ORDER BY start LOOP
        IF curr_order_id IS DISTINCT FROM row.order_id THEN
            -- Insert previous aggregated row
            INSERT INTO aggregated_data VALUES (curr_order_id, curr_start, curr_end, curr_count);
            -- Reset for new group
            curr_order_id := row.order_id;
            curr_start := row.start;
            curr_end := row.end;
            curr_count := row.count;
        ELSE
            -- Aggregate within the same group
            curr_end := row.end;
            curr_count := curr_count + row.count;
        END IF;
    END LOOP;
END $$;

Node.js மற்றும் SQL ஒருங்கிணைப்புடன் ஜாவாஸ்கிரிப்ட் பின்தள தீர்வு

இந்த பின்தள தீர்வு SQL தரவை மாறும் வகையில் செயலாக்க Node.js ஐப் பயன்படுத்துகிறது, பிழை கையாளுதல் மற்றும் மட்டு செயல்பாடுகளை உள்ளடக்கியது.

const { Client } = require('pg'); // PostgreSQL client
const aggregateData = async () => {
    const client = new Client({
        user: 'user',
        host: 'localhost',
        database: 'production_db',
        password: 'password',
        port: 5432
    });
    try {
        await client.connect();
        const query = `WITH lp AS (
            SELECT *, LEAD(order_id) OVER (ORDER BY start) AS next_id FROM production
        )
        SELECT order_id, MIN(start) AS start, MAX(end) AS end, SUM(count) AS count
        FROM lp
        GROUP BY order_id
        ORDER BY MIN(start);`;
        const result = await client.query(query);
        console.log(result.rows);
    } catch (err) {
        console.error('Error executing query:', err);
    } finally {
        await client.end();
    }
};
aggregateData();

SQL உடன் நேர-தொடர் தரவுகளை ஒருங்கிணைப்பதற்கான மேம்பட்ட நுட்பங்கள்

உடன் பணிபுரியும் போது நேரத் தொடர் தரவு, குறிப்பாக தரவுத்தளங்களில் ஆர்டர்_ஐடி தனித்தன்மை வாய்ந்தது அல்ல, திரட்டல் சிக்கல்களைத் தீர்ப்பதற்கு ஆக்கப்பூர்வமான நுட்பங்கள் தேவை. நிலையான SQL வினவல்களுக்கு அப்பால், சாளர செயல்பாடுகள், சுழல்நிலை வினவல்கள் மற்றும் நிபந்தனை ஒருங்கிணைப்புகள் போன்ற மேம்பட்ட செயல்பாடுகள் இத்தகைய சிக்கல்களைக் கையாளும் சக்திவாய்ந்த கருவிகளாகும். இந்த அணுகுமுறைகள், உள்ளீட்டு அமைப்பு தரமற்றதாக இருந்தாலும், தரவைத் திறம்பட குழுவாக்கவும், பகுப்பாய்வு செய்யவும் மற்றும் செயலாக்கவும் உங்களை அனுமதிக்கிறது. இந்த நுட்பங்களுக்கான பொதுவான பயன்பாடு, உற்பத்தி கண்காணிப்பு அமைப்புகளில் ஆர்டர்கள் பல வரிசைகளாக உடைக்கப்படுகின்றன, ஒவ்வொன்றும் ஒரு குறிப்பிட்ட நேர இடைவெளியைக் குறிக்கும்.

எடுத்துக்காட்டாக, சுழல்நிலை வினவல்கள் மிகவும் சிக்கலான நிகழ்வுகளைத் தீர்க்கப் பயன்படுத்தப்படலாம், அங்கு தரவு பல வரிசைகளில் மீண்டும் மீண்டும் இணைக்கப்பட வேண்டும். ஆர்டர்கள் காலப்போக்கில் துண்டு துண்டாக இருக்கும்போது அல்லது தரவு இடைவெளிகளை நிரப்ப வேண்டியிருக்கும் போது இது மிகவும் பயனுள்ளதாக இருக்கும். சுழல்நிலை வினவல்கள் டெவலப்பர்கள் தரவை தர்க்கரீதியாக "நடக்க" அனுமதிக்கின்றன, படிப்படியாக முடிவுகளை உருவாக்குகின்றன. கூடுதலாக, சாளர செயல்பாடுகளில் `பார்டிஷன் பை`ஐப் பயன்படுத்துவது, எங்களின் முந்தைய உதாரணங்களில் காணப்பட்டது, பகுப்பாய்வுக்கான தரவுப் பகுதிகளைத் தனிமைப்படுத்த உதவுகிறது, ஒன்றுடன் ஒன்று காட்சிகளில் தவறான திரட்டல்களின் அபாயத்தைக் குறைக்கிறது.

இறுதியாக, நேர முத்திரைகள் போன்ற தரவு வகைகளின் நுணுக்கங்களைப் புரிந்துகொள்வது மற்றும் அவற்றை எவ்வாறு கையாள்வது என்பது நேரத் தொடர் SQL இல் முக்கியமானது. வேறுபாடுகளைக் கணக்கிடுவது, வரம்புகளைப் பிரித்தெடுப்பது அல்லது மேலெழுதல்களை நிர்வகிப்பது எப்படி என்பதைத் தெரிந்துகொள்வது, உங்கள் திரட்டல்கள் துல்லியமாகவும் அர்த்தமுள்ளதாகவும் இருப்பதை உறுதிசெய்கிறது. எடுத்துக்காட்டாக, ஒன்றுடன் ஒன்று ஆர்டர்களுக்கான எண்ணிக்கையைச் சுருக்கும்போது, எந்த நேர வரம்பும் இருமுறை எண்ணப்படாமல் இருப்பதை உறுதிசெய்ய, சிறப்பு தர்க்கத்தைப் பயன்படுத்தலாம். துல்லியமான நேர-உணர்திறன் தரவை நம்பியிருக்கும் வணிகங்களுக்கான நம்பகமான டாஷ்போர்டுகள் அல்லது அறிக்கைகளை உருவாக்க இந்த நுட்பங்கள் இன்றியமையாதவை. 🚀

SQL நேர-தொடர் ஒருங்கிணைப்பு பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்

நோக்கம் என்ன LEAD() மற்றும் LAG() SQL இல்?
தி LEAD() செயல்பாடு அடுத்த வரிசையில் இருந்து மதிப்பைப் பெறுகிறது LAG() முந்தைய வரிசையிலிருந்து மதிப்பை மீட்டெடுக்கிறது. மாற்றங்கள் அல்லது வரிசைகளில் ஏற்படும் மாற்றங்களை அடையாளம் காண அவை பயன்படுத்தப்படுகின்றன, அதாவது மாற்றங்களைக் கண்காணிப்பது போன்றவை ஆர்டர்_ஐடி.
நான் எப்படி பயன்படுத்துவது GROUP BY நேரத் தொடர் தரவுகளுக்கு?
நீங்கள் பயன்படுத்தலாம் GROUP BY ஒரு பொதுவான நெடுவரிசையின் அடிப்படையில் வரிசைகளை ஒருங்கிணைக்க ஆர்டர்_ஐடி, போன்ற மொத்த செயல்பாடுகளைப் பயன்படுத்தும்போது SUM() அல்லது MAX() குழு முழுவதும் மதிப்புகளை இணைக்க.
என்ன பலன்கள் WITH பொதுவான அட்டவணை வெளிப்பாடுகள் (CTEs)?
CTE கள் வினவல்களை எளிதாக்குகிறது, அவை படிக்கவும் மீண்டும் பயன்படுத்தவும் எளிதான தற்காலிக முடிவுத் தொகுப்புகளை வரையறுக்க உங்களை அனுமதிக்கிறது. உதாரணமாக, ஒரு CTE ஆனது ஒரு குழுவின் தொடக்கத்தையும் முடிவையும் ஒருங்கிணைக்கும் முன் அடையாளம் காண முடியும்.
நேரத் தொடர் திரட்டலுக்கு நான் சுழல்நிலை வினவல்களைப் பயன்படுத்தலாமா?
ஆம்! ஒன்றுக்கொன்று சார்ந்திருக்கும் தரவு வரிசைகளை இணைக்க, சுழல்நிலை வினவல்கள் பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, மிகவும் சிக்கலான திரட்டல்களுக்கு ஒன்றுடன் ஒன்று நேரங்களைக் கொண்ட வரிசைகளை "சங்கிலி" செய்யலாம்.
ஒன்றுடன் ஒன்று நேர வரம்புகளைக் கையாளும் போது துல்லியத்தை எவ்வாறு உறுதி செய்வது?
இருமுறை எண்ணுவதைத் தவிர்க்க, வடிகட்டுதல் அல்லது எல்லைகளை அமைத்தல் போன்ற நிபந்தனை தர்க்கத்தை உங்கள் வினவலில் பயன்படுத்தவும். இணைத்தல் CASE சாளர செயல்பாடுகளுடன் கூடிய அறிக்கைகள் இந்த மேலெழுதல்களை நிர்வகிக்க உதவும்.

SQL திரட்டல் நுண்ணறிவுகளுடன் முடிவடைகிறது

மீண்டும் மீண்டும் எவ்வாறு கையாள்வது என்பதைப் புரிந்துகொள்வது ஆர்டர்_ஐடி துல்லியமான தரவு செயலாக்கத்திற்கு நேரத் தொடர் தரவுகளின் மதிப்புகள் முக்கியமானவை. சிக்கலான வினவல்களை எளிதாக்குவதற்கும் அர்த்தமுள்ள முடிவுகளை உறுதி செய்வதற்கும் CTEகள் மற்றும் சாளர செயல்பாடுகள் போன்ற பல்வேறு நுட்பங்களை இந்தக் கட்டுரை சிறப்பித்துள்ளது. ஒன்றுடன் ஒன்று அல்லது துண்டு துண்டான ஆர்டர்களை உள்ளடக்கிய காட்சிகளுக்கு இந்த உத்திகள் அவசியம்.

நீங்கள் ஒரு தயாரிப்பு டாஷ்போர்டை உருவாக்கினாலும் அல்லது நேர-உணர்திறன் தரவை பகுப்பாய்வு செய்தாலும், இந்த SQL திறன்கள் உங்கள் திறன்களை உயர்த்தும். மேம்பட்ட செயல்பாடுகளுடன் மட்டு வினவல் வடிவமைப்பை இணைப்பது உங்கள் தீர்வுகள் திறமையானதாகவும் பராமரிக்கக்கூடியதாகவும் இருப்பதை உறுதி செய்கிறது. நேர-தொடர் தரவு பகுப்பாய்வின் முழு திறனையும் திறக்க உங்கள் திட்டங்களில் இந்த முறைகளைப் பயன்படுத்தவும்! 😊

SQL நேர-தொடர் ஒருங்கிணைப்புக்கான ஆதாரங்கள் மற்றும் குறிப்புகள்

PostgreSQL அதிகாரப்பூர்வ ஆவணத்தில் இருந்து SQL சாளர செயல்பாடுகள் மற்றும் திரட்டல் எடுத்துக்காட்டுகளால் ஈர்க்கப்பட்ட உள்ளடக்கம். மேலும் விவரங்களுக்கு, பார்க்கவும் PostgreSQL சாளர செயல்பாடுகள் ஆவணப்படுத்தல் .
தரவுத்தள வடிவமைப்பு மற்றும் பகுப்பாய்வு வழிகாட்டிகளிலிருந்து தழுவிய நிஜ-உலக பயன்பாட்டு வழக்குகள் SQL ஷேக் , SQL நுண்ணறிவுக்கான சிறந்த ஆதாரம்.
நேரத் தொடர் தரவைக் கையாள்வதற்கான சிறந்த நடைமுறைகள் பற்றிய பயிற்சிகளிலிருந்து பெறப்பட்டது GeeksforGeeks , நிரலாக்க மற்றும் SQL அடிப்படைகளுக்கான தளம்.

மீண்டும் மீண்டும் வரும் வரிசை எண்களுடன் காலவரிசை அட்டவணையில் நெடுவரிசைகளைச் சேர்ப்பது எப்படி