ಸಣ್ಣ ಡೇಟಾ ಗೋದಾಮಿನಲ್ಲಿ ಇಟಿಎಲ್ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದು

ಸಂಬಂಧಿತ ಡೇಟಾಬೇಸ್‌ಗಳಾಗಿ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯಲು, ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಲೋಡ್ ಮಾಡಲು ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ರಚಿಸಲು ಅನೇಕರು ವಿಶೇಷ ಸಾಧನಗಳನ್ನು ಬಳಸುತ್ತಾರೆ. ಕೆಲಸ ಮಾಡುವ ಉಪಕರಣಗಳ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಲಾಗ್ ಮಾಡಲಾಗಿದೆ, ದೋಷಗಳನ್ನು ನಿವಾರಿಸಲಾಗಿದೆ.

ದೋಷದ ಸಂದರ್ಭದಲ್ಲಿ, ಸಾಧನವು ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ವಿಫಲವಾಗಿದೆ ಮತ್ತು ಯಾವ ಮಾಡ್ಯೂಲ್‌ಗಳು (ಸಾಮಾನ್ಯವಾಗಿ ಜಾವಾ) ಎಲ್ಲಿ ನಿಲ್ಲಿಸಿದವು ಎಂಬ ಮಾಹಿತಿಯನ್ನು ಲಾಗ್ ಒಳಗೊಂಡಿದೆ. ಕೊನೆಯ ಸಾಲುಗಳಲ್ಲಿ, ನೀವು ಡೇಟಾಬೇಸ್ ದೋಷವನ್ನು ಕಾಣಬಹುದು, ಉದಾಹರಣೆಗೆ, ಟೇಬಲ್ ಅನನ್ಯ ಕೀ ಉಲ್ಲಂಘನೆ.

ETL ದೋಷ ಮಾಹಿತಿಯು ಯಾವ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ ಎಂಬ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು, ಕಳೆದ ಎರಡು ವರ್ಷಗಳಲ್ಲಿ ಸಂಭವಿಸಿದ ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳನ್ನು ನಾನು ದೊಡ್ಡ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ವರ್ಗೀಕರಿಸಿದ್ದೇನೆ.

ಡೇಟಾಬೇಸ್ ದೋಷಗಳು ಸಾಕಷ್ಟು ಸ್ಥಳಾವಕಾಶವಿಲ್ಲ, ಸಂಪರ್ಕ ಕಳೆದುಕೊಂಡಿರುವುದು, ಸೆಷನ್ ಹ್ಯಾಂಗ್, ಇತ್ಯಾದಿ.

ತಾರ್ಕಿಕ ದೋಷಗಳು ಟೇಬಲ್ ಕೀಗಳ ಉಲ್ಲಂಘನೆ, ಮಾನ್ಯವಲ್ಲದ ವಸ್ತುಗಳು, ವಸ್ತುಗಳಿಗೆ ಪ್ರವೇಶದ ಕೊರತೆ ಇತ್ಯಾದಿಗಳನ್ನು ಒಳಗೊಂಡಿವೆ.
ಶೆಡ್ಯೂಲರ್ ಸಮಯಕ್ಕೆ ಪ್ರಾರಂಭವಾಗದಿರಬಹುದು, ಅದು ಫ್ರೀಜ್ ಆಗಬಹುದು, ಇತ್ಯಾದಿ.

ಸರಳ ತಪ್ಪುಗಳನ್ನು ಸರಿಪಡಿಸಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. ಉತ್ತಮ ETL ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನದನ್ನು ತನ್ನದೇ ಆದ ಮೇಲೆ ನಿಭಾಯಿಸುತ್ತದೆ.

ಸಂಕೀರ್ಣ ದೋಷಗಳು ಡೇಟಾ ಮೂಲಗಳನ್ನು ಅನ್ವೇಷಿಸಲು, ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಅಗತ್ಯವಾಗಿಸುತ್ತದೆ. ಆಗಾಗ್ಗೆ ಬದಲಾವಣೆಯ ಪರೀಕ್ಷೆ ಮತ್ತು ನಿಯೋಜನೆಯ ಅಗತ್ಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಅರ್ಧದಷ್ಟು ಡೇಟಾಬೇಸ್ಗೆ ಸಂಬಂಧಿಸಿದೆ. ಎಲ್ಲಾ ತಪ್ಪುಗಳಲ್ಲಿ 48% ಸರಳ ತಪ್ಪುಗಳಾಗಿವೆ.
ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಮೂರನೇ ಒಂದು ಭಾಗವು ಶೇಖರಣಾ ತರ್ಕ ಅಥವಾ ಮಾದರಿಯನ್ನು ಬದಲಾಯಿಸುವುದಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ, ಈ ದೋಷಗಳಲ್ಲಿ ಅರ್ಧಕ್ಕಿಂತ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ.

ಮತ್ತು ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಕಾಲು ಭಾಗಕ್ಕಿಂತಲೂ ಕಡಿಮೆ ಕಾರ್ಯ ವೇಳಾಪಟ್ಟಿಗೆ ಸಂಬಂಧಿಸಿದೆ, ಅದರಲ್ಲಿ 18% ಸರಳ ದೋಷಗಳಾಗಿವೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ಸಂಭವಿಸುವ ಎಲ್ಲಾ ದೋಷಗಳಲ್ಲಿ 22% ಸಂಕೀರ್ಣವಾಗಿದೆ, ಮತ್ತು ಅವರ ತಿದ್ದುಪಡಿಗೆ ಹೆಚ್ಚಿನ ಗಮನ ಮತ್ತು ಸಮಯ ಬೇಕಾಗುತ್ತದೆ. ಅವು ವಾರಕ್ಕೊಮ್ಮೆ ಸಂಭವಿಸುತ್ತವೆ. ಆದರೆ ಸರಳ ತಪ್ಪುಗಳು ಬಹುತೇಕ ಪ್ರತಿದಿನ ಸಂಭವಿಸುತ್ತವೆ.

ನಿಸ್ಸಂಶಯವಾಗಿ, ದೋಷದ ಸ್ಥಳವನ್ನು ಲಾಗ್‌ನಲ್ಲಿ ಸಾಧ್ಯವಾದಷ್ಟು ನಿಖರವಾಗಿ ಸೂಚಿಸಿದಾಗ ಮತ್ತು ಸಮಸ್ಯೆಯ ಮೂಲವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕನಿಷ್ಠ ಸಮಯ ಬೇಕಾಗುತ್ತದೆ ಎಂದು ETL ಪ್ರಕ್ರಿಯೆಗಳ ಮೇಲ್ವಿಚಾರಣೆಯು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ.

ಪರಿಣಾಮಕಾರಿ ಮೇಲ್ವಿಚಾರಣೆ

ETL ಮಾನಿಟರಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಾನು ಏನನ್ನು ನೋಡಲು ಬಯಸುತ್ತೇನೆ?

ಪ್ರಾರಂಭಿಸಿ - ಅವನು ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ,
ಮೂಲ - ಡೇಟಾ ಮೂಲ,
ಲೇಯರ್ - ಯಾವ ಮಟ್ಟದ ಸಂಗ್ರಹಣೆಯನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ,
ಇಟಿಎಲ್ ಉದ್ಯೋಗದ ಹೆಸರು - ಅಪ್‌ಲೋಡ್ ಪ್ರಕ್ರಿಯೆ, ಇದು ಹಲವು ಸಣ್ಣ ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ,
ಹಂತ ಸಂಖ್ಯೆ - ನಿರ್ವಹಿಸುತ್ತಿರುವ ಹಂತದ ಸಂಖ್ಯೆ,
ಬಾಧಿತ ಸಾಲುಗಳು - ಎಷ್ಟು ಡೇಟಾವನ್ನು ಈಗಾಗಲೇ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗಿದೆ,
ಅವಧಿ ಸೆಕೆಂಡ್ - ಇದು ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ,
ಸ್ಥಿತಿ - ಎಲ್ಲವೂ ಸರಿಯಾಗಿದೆಯೋ ಇಲ್ಲವೋ: ಸರಿ, ದೋಷ, ರನ್ನಿಂಗ್, ಹ್ಯಾಂಗ್ಸ್
ಸಂದೇಶ - ಕೊನೆಯ ಯಶಸ್ವಿ ಸಂದೇಶ ಅಥವಾ ದೋಷ ವಿವರಣೆ.

ನಮೂದುಗಳ ಸ್ಥಿತಿಯನ್ನು ಆಧರಿಸಿ, ನೀವು ಇಮೇಲ್ ಕಳುಹಿಸಬಹುದು. ಇತರ ಸದಸ್ಯರಿಗೆ ಪತ್ರ. ಯಾವುದೇ ದೋಷಗಳಿಲ್ಲದಿದ್ದರೆ, ಪತ್ರವು ಅಗತ್ಯವಿಲ್ಲ.

ಹೀಗಾಗಿ, ದೋಷದ ಸಂದರ್ಭದಲ್ಲಿ, ಘಟನೆಯ ಸ್ಥಳವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ಮಾನಿಟರಿಂಗ್ ಟೂಲ್ ಸ್ವತಃ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಎಂದು ಕೆಲವೊಮ್ಮೆ ಸಂಭವಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ವೀಕ್ಷಣೆ (ವೀಕ್ಷಣೆ) ಅನ್ನು ಕರೆಯಲು ಸಾಧ್ಯವಿದೆ, ಅದರ ಆಧಾರದ ಮೇಲೆ ವರದಿಯನ್ನು ನಿರ್ಮಿಸಲಾಗಿದೆ.

ETL ಮಾನಿಟರಿಂಗ್ ಟೇಬಲ್

ಇಟಿಎಲ್ ಪ್ರಕ್ರಿಯೆಗಳ ಮೇಲ್ವಿಚಾರಣೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಒಂದು ಟೇಬಲ್ ಮತ್ತು ಒಂದು ವೀಕ್ಷಣೆ ಸಾಕು.

ಇದನ್ನು ಮಾಡಲು, ನೀವು ಹಿಂತಿರುಗಬಹುದು ನಿಮ್ಮ ಕಡಿಮೆ ಸಂಗ್ರಹಣೆ ಮತ್ತು sqlite ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಮೂಲಮಾದರಿಯನ್ನು ರಚಿಸಿ.

ಡಿಡಿಎಲ್ ಕೋಷ್ಟಕಗಳು

CREATE TABLE UTL_JOB_STATUS (
/* Table for logging of job execution log. Important that the job has the steps ETL_START and ETL_END or ETL_ERROR */
  UTL_JOB_STATUS_ID INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
  SID               INTEGER NOT NULL DEFAULT -1, /* Session Identificator. Unique for every Run of job */
  LOG_DT            INTEGER NOT NULL DEFAULT 0,  /* Date time */
  LOG_D             INTEGER NOT NULL DEFAULT 0,  /* Date */
  JOB_NAME          TEXT NOT NULL DEFAULT 'N/A', /* Job name like JOB_STG2DM_GEO */
  STEP_NAME         TEXT NOT NULL DEFAULT 'N/A', /* ETL_START, ... , ETL_END/ETL_ERROR */
  STEP_DESCR        TEXT,                        /* Description of task or error message */
  UNIQUE (SID, JOB_NAME, STEP_NAME)
);
INSERT INTO UTL_JOB_STATUS (UTL_JOB_STATUS_ID) VALUES (-1);

DDL ಅನ್ನು ವೀಕ್ಷಿಸಿ/ವರದಿ ಮಾಡಿ

CREATE VIEW IF NOT EXISTS UTL_JOB_STATUS_V
AS /* Content: Package Execution Log for last 3 Months. */
WITH SRC AS (
  SELECT LOG_D,
    LOG_DT,
    UTL_JOB_STATUS_ID,
    SID,
	CASE WHEN INSTR(JOB_NAME, 'FTP') THEN 'TRANSFER' /* file transfer */
	     WHEN INSTR(JOB_NAME, 'STG') THEN 'STAGE' /* stage */
	     WHEN INSTR(JOB_NAME, 'CLS') THEN 'CLEANSING' /* cleansing */
	     WHEN INSTR(JOB_NAME, 'DIM') THEN 'DIMENSION' /* dimension */
	     WHEN INSTR(JOB_NAME, 'FCT') THEN 'FACT' /* fact */
		 WHEN INSTR(JOB_NAME, 'ETL') THEN 'STAGE-MART' /* data mart */
	     WHEN INSTR(JOB_NAME, 'RPT') THEN 'REPORT' /* report */
	     ELSE 'N/A' END AS LAYER,
	CASE WHEN INSTR(JOB_NAME, 'ACCESS') THEN 'ACCESS LOG' /* source */
	     WHEN INSTR(JOB_NAME, 'MASTER') THEN 'MASTER DATA' /* source */
	     WHEN INSTR(JOB_NAME, 'AD-HOC') THEN 'AD-HOC' /* source */
	     ELSE 'N/A' END AS SOURCE,
    JOB_NAME,
    STEP_NAME,
    CASE WHEN STEP_NAME='ETL_START' THEN 1 ELSE 0 END AS START_FLAG,
    CASE WHEN STEP_NAME='ETL_END' THEN 1 ELSE 0 END AS END_FLAG,
    CASE WHEN STEP_NAME='ETL_ERROR' THEN 1 ELSE 0 END AS ERROR_FLAG,
    STEP_NAME || ' : ' || STEP_DESCR AS STEP_LOG,
	SUBSTR( SUBSTR(STEP_DESCR, INSTR(STEP_DESCR, '***')+4), 1, INSTR(SUBSTR(STEP_DESCR, INSTR(STEP_DESCR, '***')+4), '***')-2 ) AS AFFECTED_ROWS
  FROM UTL_JOB_STATUS
  WHERE datetime(LOG_D, 'unixepoch') >= date('now', 'start of month', '-3 month')
)
SELECT JB.SID,
  JB.MIN_LOG_DT AS START_DT,
  strftime('%d.%m.%Y %H:%M', datetime(JB.MIN_LOG_DT, 'unixepoch')) AS LOG_DT,
  JB.SOURCE,
  JB.LAYER,
  JB.JOB_NAME,
  CASE
  WHEN JB.ERROR_FLAG = 1 THEN 'ERROR'
  WHEN JB.ERROR_FLAG = 0 AND JB.END_FLAG = 0 AND strftime('%s','now') - JB.MIN_LOG_DT > 0.5*60*60 THEN 'HANGS' /* half an hour */
  WHEN JB.ERROR_FLAG = 0 AND JB.END_FLAG = 0 THEN 'RUNNING'
  ELSE 'OK'
  END AS STATUS,
  ERR.STEP_LOG     AS STEP_LOG,
  JB.CNT           AS STEP_CNT,
  JB.AFFECTED_ROWS AS AFFECTED_ROWS,
  strftime('%d.%m.%Y %H:%M', datetime(JB.MIN_LOG_DT, 'unixepoch')) AS JOB_START_DT,
  strftime('%d.%m.%Y %H:%M', datetime(JB.MAX_LOG_DT, 'unixepoch')) AS JOB_END_DT,
  JB.MAX_LOG_DT - JB.MIN_LOG_DT AS JOB_DURATION_SEC
FROM
  ( SELECT SID, SOURCE, LAYER, JOB_NAME,
           MAX(UTL_JOB_STATUS_ID) AS UTL_JOB_STATUS_ID,
           MAX(START_FLAG)       AS START_FLAG,
           MAX(END_FLAG)         AS END_FLAG,
           MAX(ERROR_FLAG)       AS ERROR_FLAG,
           MIN(LOG_DT)           AS MIN_LOG_DT,
           MAX(LOG_DT)           AS MAX_LOG_DT,
           SUM(1)                AS CNT,
           SUM(IFNULL(AFFECTED_ROWS, 0)) AS AFFECTED_ROWS
    FROM SRC
    GROUP BY SID, SOURCE, LAYER, JOB_NAME
  ) JB,
  ( SELECT UTL_JOB_STATUS_ID, SID, JOB_NAME, STEP_LOG
    FROM SRC
    WHERE 1 = 1
  ) ERR
WHERE 1 = 1
  AND JB.SID = ERR.SID
  AND JB.JOB_NAME = ERR.JOB_NAME
  AND JB.UTL_JOB_STATUS_ID = ERR.UTL_JOB_STATUS_ID
ORDER BY JB.MIN_LOG_DT DESC, JB.SID DESC, JB.SOURCE;

SQL ಹೊಸ ಅಧಿವೇಶನ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

SELECT SUM (
  CASE WHEN start_job.JOB_NAME IS NOT NULL AND end_job.JOB_NAME IS NULL /* existed job finished */
	    AND NOT ( 'y' = 'n' ) /* force restart PARAMETER */
       THEN 1 ELSE 0
  END ) AS IS_RUNNING
  FROM
    ( SELECT 1 AS dummy FROM UTL_JOB_STATUS WHERE sid = -1) d_job
  LEFT OUTER JOIN
    ( SELECT JOB_NAME, SID, 1 AS dummy
      FROM UTL_JOB_STATUS
      WHERE JOB_NAME = 'RPT_ACCESS_LOG' /* job name PARAMETER */
	    AND STEP_NAME = 'ETL_START'
      GROUP BY JOB_NAME, SID
    ) start_job /* starts */
  ON d_job.dummy = start_job.dummy
  LEFT OUTER JOIN
    ( SELECT JOB_NAME, SID
      FROM UTL_JOB_STATUS
      WHERE JOB_NAME = 'RPT_ACCESS_LOG'  /* job name PARAMETER */
	    AND STEP_NAME in ('ETL_END', 'ETL_ERROR') /* stop status */
      GROUP BY JOB_NAME, SID
    ) end_job /* ends */
  ON start_job.JOB_NAME = end_job.JOB_NAME
     AND start_job.SID = end_job.SID

ಟೇಬಲ್ ವೈಶಿಷ್ಟ್ಯಗಳು:

• ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ ಪ್ರಕ್ರಿಯೆಯ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯವನ್ನು ETL_START ಮತ್ತು ETL_END ಹಂತಗಳ ಮೂಲಕ ಅನುಸರಿಸಬೇಕು
• ದೋಷದ ಸಂದರ್ಭದಲ್ಲಿ, ಅದರ ವಿವರಣೆಯೊಂದಿಗೆ ETL_ERROR ಹಂತವನ್ನು ರಚಿಸಬೇಕು
• ಸಂಸ್ಕರಿಸಿದ ಡೇಟಾದ ಪ್ರಮಾಣವನ್ನು ಹೈಲೈಟ್ ಮಾಡಬೇಕು, ಉದಾಹರಣೆಗೆ, ನಕ್ಷತ್ರ ಚಿಹ್ನೆಗಳೊಂದಿಗೆ
• ಅದೇ ವಿಧಾನವನ್ನು force_restart=y ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬಹುದು, ಅದು ಇಲ್ಲದೆ ಅಧಿವೇಶನ ಸಂಖ್ಯೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ಕಾರ್ಯವಿಧಾನಕ್ಕೆ ಮಾತ್ರ ನೀಡಲಾಗುತ್ತದೆ
• ಸಾಮಾನ್ಯ ಕ್ರಮದಲ್ಲಿ, ನೀವು ಅದೇ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ವಿಧಾನವನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಚಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

ಟೇಬಲ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅಗತ್ಯವಾದ ಕಾರ್ಯಾಚರಣೆಗಳು ಹೀಗಿವೆ:

• ಚಾಲನೆಯಲ್ಲಿರುವ ETL ಕಾರ್ಯವಿಧಾನದ ಅಧಿವೇಶನ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯುವುದು
• ಲಾಗ್ ಪ್ರವೇಶವನ್ನು ಟೇಬಲ್‌ಗೆ ಸೇರಿಸಿ
• ETL ಕಾರ್ಯವಿಧಾನದ ಕೊನೆಯ ಯಶಸ್ವಿ ದಾಖಲೆಯನ್ನು ಪಡೆಯುವುದು

ಒರಾಕಲ್ ಅಥವಾ ಪೋಸ್ಟ್‌ಗ್ರೆಸ್‌ನಂತಹ ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ, ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. sqlite ಗೆ ಬಾಹ್ಯ ಯಾಂತ್ರಿಕತೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು PHP ನಲ್ಲಿ ಮಾದರಿ.

ತೀರ್ಮಾನಕ್ಕೆ

ಹೀಗಾಗಿ, ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಸಾಧನಗಳಲ್ಲಿನ ದೋಷ ಸಂದೇಶಗಳು ಮೆಗಾ-ಪ್ರಮುಖ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತವೆ. ಆದರೆ ಸಮಸ್ಯೆಯ ಕಾರಣವನ್ನು ತ್ವರಿತವಾಗಿ ಕಂಡುಹಿಡಿಯಲು ಅವುಗಳನ್ನು ಸೂಕ್ತವೆಂದು ಕರೆಯುವುದು ಕಷ್ಟ. ಕಾರ್ಯವಿಧಾನಗಳ ಸಂಖ್ಯೆಯು ನೂರು ಸಮೀಪಿಸಿದಾಗ, ಪ್ರಕ್ರಿಯೆಯ ಮೇಲ್ವಿಚಾರಣೆಯು ಸಂಕೀರ್ಣ ಯೋಜನೆಯಾಗಿ ಬದಲಾಗುತ್ತದೆ.

ಲೇಖನವು ಮೂಲಮಾದರಿಯ ರೂಪದಲ್ಲಿ ಸಮಸ್ಯೆಗೆ ಸಂಭವನೀಯ ಪರಿಹಾರದ ಉದಾಹರಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಸಂಪೂರ್ಣ ಸಣ್ಣ ರೆಪೊಸಿಟರಿ ಮೂಲಮಾದರಿಯು ಗಿಟ್ಲ್ಯಾಬ್‌ನಲ್ಲಿ ಲಭ್ಯವಿದೆ SQLite PHP ETL ಉಪಯುಕ್ತತೆಗಳು.

ಮೂಲ: www.habr.com