ibd ਫਾਈਲ ਦੇ ਬਾਈਟ-ਬਾਈ-ਬਾਈਟ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਢਾਂਚਾ ਫਾਈਲ ਤੋਂ ਬਿਨਾਂ XtraDB ਟੇਬਲਾਂ ਤੋਂ ਡਾਟਾ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨਾ

prehistory

ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਹੋਇਆ ਕਿ ਸਰਵਰ 'ਤੇ ਇੱਕ ਰੈਨਸਮਵੇਅਰ ਵਾਇਰਸ ਦੁਆਰਾ ਹਮਲਾ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਸ ਨੇ, ਇੱਕ "ਖੁਸ਼ਕਿਸਮਤ ਦੁਰਘਟਨਾ" ਦੁਆਰਾ, ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ .ibd ਫਾਈਲਾਂ (ਇਨੋਡਬੀ ਟੇਬਲ ਦੀਆਂ ਕੱਚੀਆਂ ਡੇਟਾ ਫਾਈਲਾਂ) ਨੂੰ ਅਛੂਹ ਛੱਡ ਦਿੱਤਾ, ਪਰ ਉਸੇ ਸਮੇਂ .fpm ਫਾਈਲਾਂ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਐਨਕ੍ਰਿਪਟ ਕਰ ਦਿੱਤਾ ( ਢਾਂਚਾ ਫਾਈਲਾਂ). ਇਸ ਸਥਿਤੀ ਵਿੱਚ, .idb ਨੂੰ ਇਸ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ:

• ਮਿਆਰੀ ਸਾਧਨਾਂ ਅਤੇ ਗਾਈਡਾਂ ਰਾਹੀਂ ਬਹਾਲੀ ਦੇ ਅਧੀਨ। ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਲਈ, ਇੱਕ ਸ਼ਾਨਦਾਰ ਹੈ ਬਣਨਾ;
• ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਇਨਕ੍ਰਿਪਟਡ ਟੇਬਲ। ਜ਼ਿਆਦਾਤਰ ਇਹ ਵੱਡੇ ਟੇਬਲ ਹਨ, ਜਿਸ ਲਈ (ਜਿਵੇਂ ਕਿ ਮੈਂ ਸਮਝਦਾ ਹਾਂ) ਹਮਲਾਵਰਾਂ ਕੋਲ ਪੂਰੀ ਐਨਕ੍ਰਿਪਸ਼ਨ ਲਈ ਲੋੜੀਂਦੀ RAM ਨਹੀਂ ਸੀ;
• ਖੈਰ, ਪੂਰੀ ਤਰ੍ਹਾਂ ਏਨਕ੍ਰਿਪਟਡ ਟੇਬਲ ਜਿਨ੍ਹਾਂ ਨੂੰ ਰੀਸਟੋਰ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ।

ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸੰਭਵ ਸੀ ਕਿ ਟੇਬਲ ਕਿਸ ਵਿਕਲਪ ਨਾਲ ਸਬੰਧਤ ਹਨ ਇਸ ਨੂੰ ਲੋੜੀਂਦੇ ਏਨਕੋਡਿੰਗ (ਮੇਰੇ ਕੇਸ ਵਿੱਚ ਇਹ UTF8 ਹੈ) ਦੇ ਅਧੀਨ ਕਿਸੇ ਵੀ ਟੈਕਸਟ ਐਡੀਟਰ ਵਿੱਚ ਖੋਲ੍ਹ ਕੇ ਅਤੇ ਟੈਕਸਟ ਖੇਤਰਾਂ ਦੀ ਮੌਜੂਦਗੀ ਲਈ ਫਾਈਲ ਨੂੰ ਵੇਖਣਾ, ਉਦਾਹਰਣ ਲਈ:

ਨਾਲ ਹੀ, ਫਾਈਲ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਤੁਸੀਂ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ 0 ਬਾਈਟਾਂ ਦਾ ਨਿਰੀਖਣ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਵਾਇਰਸ ਜੋ ਬਲਾਕ ਇਨਕ੍ਰਿਪਸ਼ਨ ਐਲਗੋਰਿਦਮ (ਸਭ ਤੋਂ ਆਮ) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਉਹਨਾਂ ਨੂੰ ਵੀ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ।

ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਹਮਲਾਵਰਾਂ ਨੇ ਹਰੇਕ ਐਨਕ੍ਰਿਪਟਡ ਫਾਈਲ ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ 4-ਬਾਈਟ ਸਤਰ (1, 0, 0, 0) ਛੱਡ ਦਿੱਤੀ, ਜਿਸ ਨਾਲ ਕੰਮ ਨੂੰ ਸਰਲ ਬਣਾਇਆ ਗਿਆ। ਅਣ-ਸੰਕਰਮਿਤ ਫਾਈਲਾਂ ਦੀ ਖੋਜ ਕਰਨ ਲਈ, ਸਕ੍ਰਿਪਟ ਕਾਫ਼ੀ ਸੀ:

def opened(path):
    files = os.listdir(path)
    for f in files:
        if os.path.isfile(path + f):
            yield path + f

for full_path in opened("C:somepath"):
    file = open(full_path, "rb")
    last_string = ""
    for line in file:
        last_string = line
        file.close()
    if (last_string[len(last_string) -4:len(last_string)]) != (1, 0, 0, 0):
        print(full_path)

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

ਵਾਈਲਡਸ ਸਿਟੀ, ਬਦਕਿਸਮਤੀ ਨਾਲ, ਅਜਿਹੇ ਕੇਸ ਵਿੱਚ ਮਦਦ ਨਹੀਂ ਕਰ ਸਕਿਆ, ਜਿਸ ਕਾਰਨ ਇਹ ਲੇਖ ਲਿਖਿਆ ਜਾ ਰਿਹਾ ਹੈ।

ਬਿੰਦੂ 'ਤੇ ਪ੍ਰਾਪਤ ਕਰੋ

3 ਮਹੀਨੇ ਪਹਿਲਾਂ ਤੋਂ ਇੱਕ ਸਾਰਣੀ ਦਾ ਇੱਕ ਢਾਂਚਾ ਹੈ ਜੋ ਮੌਜੂਦਾ ਇੱਕ (ਸੰਭਵ ਤੌਰ 'ਤੇ ਇੱਕ ਖੇਤਰ, ਅਤੇ ਸੰਭਵ ਤੌਰ 'ਤੇ ਹੋਰ) ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ। ਟੇਬਲ ਬਣਤਰ:

CREATE TABLE `table_1` (
    `id` INT (11),
    `date` DATETIME ,
    `description` TEXT ,
    `id_point` INT (11),
    `id_user` INT (11),
    `date_start` DATETIME ,
    `date_finish` DATETIME ,
    `photo` INT (1),
    `id_client` INT (11),
    `status` INT (1),
    `lead__time` TIME ,
    `sendstatus` TINYINT (4)
); 

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

• id_point int(11);
• id_user int(11);
• date_start DATETIME;
• date_finish DATETIME।

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

ਸਮੱਸਿਆ 1: DATETIME ਅਤੇ TEXT ਕਿਸਮਾਂ ਵਾਲੇ ਖੇਤਰਾਂ ਵਿੱਚ NULL ਮੁੱਲ ਸਨ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਿਰਫ਼ ਫਾਈਲ ਵਿੱਚ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਇਸਦੇ ਕਾਰਨ, ਮੇਰੇ ਕੇਸ ਵਿੱਚ ਬਹਾਲ ਕਰਨ ਲਈ ਢਾਂਚੇ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਸੀ। ਨਵੇਂ ਕਾਲਮਾਂ ਵਿੱਚ, ਪੂਰਵ-ਨਿਰਧਾਰਤ ਮੁੱਲ ਖਾਲੀ ਸੀ, ਅਤੇ innodb_flush_log_at_trx_commit = 0 ਸੈਟਿੰਗ ਕਰਕੇ ਲੈਣ-ਦੇਣ ਦਾ ਕੁਝ ਹਿੱਸਾ ਖਤਮ ਹੋ ਸਕਦਾ ਹੈ, ਇਸਲਈ ਢਾਂਚੇ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਾਧੂ ਸਮਾਂ ਖਰਚ ਕਰਨਾ ਪਵੇਗਾ।

ਸਮੱਸਿਆ 2: ਇਹ ਧਿਆਨ ਵਿੱਚ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ DELETE ਰਾਹੀਂ ਮਿਟਾਈਆਂ ਗਈਆਂ ਕਤਾਰਾਂ ਸਾਰੀਆਂ ibd ਫਾਈਲ ਵਿੱਚ ਹੋਣਗੀਆਂ, ਪਰ ALTER TABLE ਨਾਲ ਉਹਨਾਂ ਦੀ ਬਣਤਰ ਨੂੰ ਅੱਪਡੇਟ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ। ਨਤੀਜੇ ਵਜੋਂ, ਡਾਟਾ ਢਾਂਚਾ ਫਾਈਲ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਇਸਦੇ ਅੰਤ ਤੱਕ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਅਕਸਰ ਓਪਟੀਮਾਈਜ਼ ਟੇਬਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਅਜਿਹੀ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ।

ਧਿਆਨ ਦੇਵੋ, DBMS ਸੰਸਕਰਣ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਉਦਾਹਰਨ ਦੂਜੇ ਪ੍ਰਮੁੱਖ ਸੰਸਕਰਣਾਂ ਲਈ ਕੰਮ ਨਾ ਕਰੇ। ਮੇਰੇ ਕੇਸ ਵਿੱਚ, mariadb 10.1.24 ਦਾ ਵਿੰਡੋਜ਼ ਵਰਜਨ ਵਰਤਿਆ ਗਿਆ ਸੀ। ਨਾਲ ਹੀ, ਹਾਲਾਂਕਿ mariadb ਵਿੱਚ ਤੁਸੀਂ InnoDB ਟੇਬਲ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਅਸਲ ਵਿੱਚ ਉਹ ਹਨ ਐਕਸਟਰਡਬੀ, ਜੋ ਕਿ InnoDB mysql ਨਾਲ ਵਿਧੀ ਦੀ ਪ੍ਰਯੋਗਤਾ ਨੂੰ ਬਾਹਰ ਰੱਖਦਾ ਹੈ।

ਫਾਈਲ ਵਿਸ਼ਲੇਸ਼ਣ

ਪਾਈਥਨ ਵਿੱਚ, ਡਾਟਾ ਕਿਸਮ ਬਾਈਟ() ਸੰਖਿਆਵਾਂ ਦੇ ਨਿਯਮਤ ਸਮੂਹ ਦੀ ਥਾਂ 'ਤੇ ਯੂਨੀਕੋਡ ਡੇਟਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਇਸ ਫਾਰਮ ਵਿੱਚ ਫਾਈਲ ਦੇਖ ਸਕਦੇ ਹੋ, ਸੁਵਿਧਾ ਲਈ ਤੁਸੀਂ ਬਾਈਟ ਐਰੇ ਨੂੰ ਇੱਕ ਨਿਯਮਤ ਐਰੇ (ਲਿਸਟ(ਉਦਾਹਰਨ_ਬਾਈਟ_ਐਰੇ)) ਵਿੱਚ ਬਦਲ ਕੇ ਬਾਈਟ ਨੂੰ ਸੰਖਿਆਤਮਕ ਰੂਪ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ। ਕਿਸੇ ਵੀ ਹਾਲਤ ਵਿੱਚ, ਦੋਵੇਂ ਤਰੀਕੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਢੁਕਵੇਂ ਹਨ.

ਕਈ ibd ਫਾਈਲਾਂ ਨੂੰ ਦੇਖਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਲੱਭ ਸਕਦੇ ਹੋ:

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜੇਕਰ ਤੁਸੀਂ ਇਹਨਾਂ ਕੀਵਰਡਸ ਦੁਆਰਾ ਫਾਈਲ ਨੂੰ ਵੰਡਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਜ਼ਿਆਦਾਤਰ ਡੇਟਾ ਦੇ ਬਲਾਕ ਵੀ ਮਿਲਣਗੇ। ਅਸੀਂ ਇੱਕ ਵਿਭਾਜਕ ਵਜੋਂ ਇਨਫਿਮਮ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।

table = table.split("infimum".encode())

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

- ਪਹਿਲੀ ਕਤਾਰ ਦੇ ਨਾਲ ਟੈਸਟ ਟੇਬਲ

- 2 ਕਤਾਰਾਂ ਨਾਲ ਟੈਸਟ ਟੇਬਲ

ਕਤਾਰ ਐਰੇ ਸਾਰਣੀ[0] ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਨੂੰ ਦੇਖਣ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਅਜੇ ਵੀ ਕੱਚਾ ਟੇਬਲ ਡੇਟਾ ਲੱਭਣ ਵਿੱਚ ਅਸਮਰੱਥ ਸੀ। ਜ਼ਿਆਦਾਤਰ ਸੰਭਾਵਨਾ ਹੈ, ਇਹ ਬਲਾਕ ਸੂਚਕਾਂਕ ਅਤੇ ਕੁੰਜੀਆਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਸਾਰਣੀ[1] ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਸੰਖਿਆਤਮਕ ਐਰੇ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੁਝ ਪੈਟਰਨ ਨੋਟ ਕਰ ਸਕਦੇ ਹੋ, ਅਰਥਾਤ:

ਇਹ ਇੱਕ ਸਤਰ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ int ਮੁੱਲ ਹਨ। ਪਹਿਲਾ ਬਾਈਟ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਸੰਖਿਆ ਸਕਾਰਾਤਮਕ ਹੈ ਜਾਂ ਨਕਾਰਾਤਮਕ। ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਸਾਰੇ ਨੰਬਰ ਸਕਾਰਾਤਮਕ ਹਨ. ਬਾਕੀ 3 ਬਾਈਟਾਂ ਤੋਂ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨੰਬਰ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ। ਸਕ੍ਰਿਪਟ:

def find_int(val: str):  # example '128, 1, 2, 3'
    val = [int(v) for v in  val.split(", ")]
    result_int = val[1]*256**2 + val[2]*256*1 + val[3]
    return result_int

ਮਿਸਾਲ ਲਈ, 128, 0, 0, 1 = 1, ਜਾਂ 128, 0, 75, 108 = 19308.
ਸਾਰਣੀ ਵਿੱਚ ਆਟੋ-ਇੰਕਰੀਮੈਂਟ ਵਾਲੀ ਇੱਕ ਪ੍ਰਾਇਮਰੀ ਕੁੰਜੀ ਸੀ, ਅਤੇ ਇਹ ਇੱਥੇ ਵੀ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ

ਟੈਸਟ ਟੇਬਲ ਤੋਂ ਡੇਟਾ ਦੀ ਤੁਲਨਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਹ ਸਾਹਮਣੇ ਆਇਆ ਕਿ DATETIME ਆਬਜੈਕਟ 5 ਬਾਈਟਾਂ ਦੇ ਹੁੰਦੇ ਹਨ ਅਤੇ 153 ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ (ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਸਾਲਾਨਾ ਅੰਤਰਾਲਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ)। ਕਿਉਂਕਿ DATTIME ਰੇਂਜ '1000-01-01' ਤੋਂ '9999-12-31' ਤੱਕ ਹੈ, ਮੈਨੂੰ ਲੱਗਦਾ ਹੈ ਕਿ ਬਾਈਟਾਂ ਦੀ ਗਿਣਤੀ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਡੇਟਾ 2016 ਤੋਂ 2019 ਦੀ ਮਿਆਦ ਵਿੱਚ ਆਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਮੰਨਾਂਗੇ ਜੋ ਕਿ 5 ਬਾਈਟ ਕਾਫ਼ੀ ਹੈ।

ਸਕਿੰਟਾਂ ਤੋਂ ਬਿਨਾਂ ਸਮਾਂ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਲਿਖੇ ਗਏ ਸਨ। ਸਕ੍ਰਿਪਟ:

day_ = lambda x: x % 64 // 2  # {x,x,X,x,x }

def hour_(x1, x2):  # {x,x,X1,X2,x}
    if x1 % 2 == 0:
        return x2 // 16
    elif x1 % 2 == 1:
        return x2 // 16 + 16
    else:
        raise ValueError

min_ = lambda x1, x2: (x1 % 16) * 4 + (x2 // 64)  # {x,x,x,X1,X2}

ਸਾਲ ਅਤੇ ਮਹੀਨੇ ਲਈ ਫੰਕਸ਼ਨਲ ਫੰਕਸ਼ਨ ਲਿਖਣਾ ਸੰਭਵ ਨਹੀਂ ਸੀ, ਇਸ ਲਈ ਮੈਨੂੰ ਇਸਨੂੰ ਹੈਕ ਕਰਨਾ ਪਿਆ. ਸਕ੍ਰਿਪਟ:

ym_list = {'2016, 1': '153, 152, 64', '2016, 2': '153, 152, 128', 
           '2016, 3': '153, 152, 192', '2016, 4': '153, 153, 0',
           '2016, 5': '153, 153, 64', '2016, 6': '153, 153, 128', 
           '2016, 7': '153, 153, 192', '2016, 8': '153, 154, 0', 
           '2016, 9': '153, 154, 64', '2016, 10': '153, 154, 128', 
           '2016, 11': '153, 154, 192', '2016, 12': '153, 155, 0',
           '2017, 1': '153, 155, 128', '2017, 2': '153, 155, 192', 
           '2017, 3': '153, 156, 0', '2017, 4': '153, 156, 64',
           '2017, 5': '153, 156, 128', '2017, 6': '153, 156, 192',
           '2017, 7': '153, 157, 0', '2017, 8': '153, 157, 64',
           '2017, 9': '153, 157, 128', '2017, 10': '153, 157, 192', 
           '2017, 11': '153, 158, 0', '2017, 12': '153, 158, 64', 
           '2018, 1': '153, 158, 192', '2018, 2': '153, 159, 0',
           '2018, 3': '153, 159, 64', '2018, 4': '153, 159, 128', 
           '2018, 5': '153, 159, 192', '2018, 6': '153, 160, 0',
           '2018, 7': '153, 160, 64', '2018, 8': '153, 160, 128',
           '2018, 9': '153, 160, 192', '2018, 10': '153, 161, 0', 
           '2018, 11': '153, 161, 64', '2018, 12': '153, 161, 128',
           '2019, 1': '153, 162, 0', '2019, 2': '153, 162, 64', 
           '2019, 3': '153, 162, 128', '2019, 4': '153, 162, 192', 
           '2019, 5': '153, 163, 0', '2019, 6': '153, 163, 64',
           '2019, 7': '153, 163, 128', '2019, 8': '153, 163, 192',
           '2019, 9': '153, 164, 0', '2019, 10': '153, 164, 64', 
           '2019, 11': '153, 164, 128', '2019, 12': '153, 164, 192',
           '2020, 1': '153, 165, 64', '2020, 2': '153, 165, 128',
           '2020, 3': '153, 165, 192','2020, 4': '153, 166, 0', 
           '2020, 5': '153, 166, 64', '2020, 6': '153, 1, 128',
           '2020, 7': '153, 166, 192', '2020, 8': '153, 167, 0', 
           '2020, 9': '153, 167, 64','2020, 10': '153, 167, 128',
           '2020, 11': '153, 167, 192', '2020, 12': '153, 168, 0'}

def year_month(x1, x2):  # {x,X,X,x,x }

    for key, value in ym_list.items():
        key = [int(k) for k in key.replace("'", "").split(", ")]
        value = [int(v) for v in value.split(", ")]
        if x1 == value[1] and x2 // 64 == value[2] // 64:
            return key
    return 0, 0

ਮੈਨੂੰ ਯਕੀਨ ਹੈ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਕਾਫ਼ੀ ਸਮਾਂ ਬਿਤਾਉਂਦੇ ਹੋ, ਤਾਂ ਇਸ ਗਲਤਫਹਿਮੀ ਨੂੰ ਠੀਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਅੱਗੇ, ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਇੱਕ ਸਟ੍ਰਿੰਗ ਤੋਂ ਇੱਕ datetime ਵਸਤੂ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ:

def find_data_time(val:str):
    val = [int(v) for v in val.split(", ")]
    day = day_(val[2])
    hour = hour_(val[2], val[3])
    minutes = min_(val[3], val[4])
    year, month = year_month(val[1], val[2])
    return datetime(year, month, day, hour, minutes)

int, int, datetime, datetime ਤੋਂ ਅਕਸਰ ਦੁਹਰਾਏ ਜਾਣ ਵਾਲੇ ਮੁੱਲਾਂ ਨੂੰ ਖੋਜਣ ਲਈ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ ਗਿਆ , ਇੰਝ ਜਾਪਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇਸ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਜਿਹਾ ਕ੍ਰਮ ਪ੍ਰਤੀ ਲਾਈਨ ਦੋ ਵਾਰ ਨਹੀਂ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ।

ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਾਨੂੰ ਲੋੜੀਂਦਾ ਡੇਟਾ ਮਿਲਦਾ ਹੈ:

fined = re.findall(r'128, d*, d*, d*, 128, d*, d*, d*, 153, 1[6,5,4,3]d, d*, d*, d*, 153, 1[6,5,4,3]d, d*, d*, d*', int_array)

ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਜਦੋਂ ਇਸ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਖੋਜ ਕਰਦੇ ਹੋ, ਤਾਂ ਲੋੜੀਂਦੇ ਖੇਤਰਾਂ ਵਿੱਚ NULL ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਹੋਵੇਗਾ, ਪਰ ਮੇਰੇ ਕੇਸ ਵਿੱਚ ਇਹ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ। ਫਿਰ ਅਸੀਂ ਉਸ ਵਿੱਚੋਂ ਲੰਘਦੇ ਹਾਂ ਜੋ ਸਾਨੂੰ ਇੱਕ ਲੂਪ ਵਿੱਚ ਮਿਲਿਆ. ਸਕ੍ਰਿਪਟ:

result = []
for val in fined:
    pre_result = []
    bd_int  = re.findall(r"128, d*, d*, d*", val)
    bd_date= re.findall(r"(153, 1[6,5,4,3]d, d*, d*, d*)", val)
    for it in bd_int:
        pre_result.append(find_int(bd_int[it]))
    for bd in bd_date:
        pre_result.append(find_data_time(bd))
    result.append(pre_result)

ਅਸਲ ਵਿੱਚ, ਇਹ ਸਭ ਹੈ, ਨਤੀਜਾ ਐਰੇ ਤੋਂ ਡੇਟਾ ਉਹ ਡੇਟਾ ਹੈ ਜਿਸਦੀ ਸਾਨੂੰ ਲੋੜ ਹੈ। ###PS।###
ਮੈਂ ਸਮਝਦਾ ਹਾਂ ਕਿ ਇਹ ਤਰੀਕਾ ਹਰ ਕਿਸੇ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੈ, ਪਰ ਲੇਖ ਦਾ ਮੁੱਖ ਟੀਚਾ ਤੁਹਾਡੀਆਂ ਸਾਰੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਬਜਾਏ ਤੁਰੰਤ ਕਾਰਵਾਈ ਕਰਨਾ ਹੈ। ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਸਭ ਤੋਂ ਸਹੀ ਹੱਲ ਇਹ ਹੋਵੇਗਾ ਕਿ ਤੁਸੀਂ ਸਰੋਤ ਕੋਡ ਦਾ ਅਧਿਐਨ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੋ ਮਾਰੀਆਡਬੀ, ਪਰ ਸੀਮਤ ਸਮੇਂ ਦੇ ਕਾਰਨ, ਮੌਜੂਦਾ ਤਰੀਕਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਜਾਪਦਾ ਸੀ।

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

ਸਰੋਤ: www.habr.com