אמת ערשטער, אָדער וואָס די סיסטעם דאַרף זיין דיזיינד באזירט אויף די דאַטאַבייס סטרוקטור

היי האבר!

מיר פאָרזעצן צו ויספאָרשן די טעמע ז'אבא и פרילינגאַרייַנגערעכנט אין די דאַטאַבייס מדרגה. הייַנט מיר פאָרשלאָגן צו לייענען וועגן וואָס, ווען דיזיינינג גרויס אַפּלאַקיישאַנז, עס איז די דאַטאַבייס סטרוקטור, און נישט די דזשאַוואַ קאָד, וואָס זאָל זיין פון באַשטימענדיק וויכטיקייט, ווי דאָס איז געטאן, און וואָס זענען די אויסנעמען צו דעם הערשן.

אין דעם גאַנץ שפּעט אַרטיקל, איך וועט דערקלערן וואָס איך טראַכטן אַז אין כּמעט אַלע קאַסעס, די דאַטן מאָדעל אין אַ אַפּלאַקיישאַן זאָל זיין דיזיינד "פֿון די דאַטאַבאַסע" אלא ווי "פֿון די קייפּאַבילאַטיז פון Java" (אָדער וועלכער קליענט שפּראַך איר זענט. ארבעטן מיט). דורך טשוזינג די רגע צוגאַנג, איר אַרייַן אַ לאַנג וועג פון ווייטיק און צאָרעס אַמאָל דיין פּרויעקט סטאַרץ צו וואַקסן.

דער אַרטיקל איז געשריבן באזירט אויף איין קשיא, געגעבן אויף סטאַק אָווערפלאָוו.

טשיקאַווע דיסקוסיעס וועגן רעדדיט אין סעקשאַנז /r/java и /r/פּראָגראַממינג.

קאָד דור

ווי סאַפּרייזד איך בין אַז עס איז אַזאַ אַ קליין סובסעט פון יוזערז וואָס, זיי זענען באַקאַנט מיט jOOQ, זענען אַוטריידזשד דורך די פאַקט אַז jOOQ עמעס פאַרלאָזנ אויף די מקור קאָד דזשענעריישאַן צו לויפן. קיין איינער איז סטאָפּפּינג איר פון ניצן jOOQ ווי איר זען פּאַסיק, און קיין איינער איז פאָרסינג איר צו נוצן קאָד דור. אָבער דורך פעליקייַט (ווי דיסקרייבד אין די מאַנואַל), jOOQ אַרבעט ווי דאָס: איר אָנהייבן מיט אַ (לעגאַט) דאַטאַבייס סטשעמאַ, פאַרקערט ינזשעניר עס מיט די jOOQ קאָד גענעראַטאָר צו באַקומען אַ סכום פון קלאסן וואָס רעפּראַזענץ דיין טישן, און דעמאָלט שרייַבן טיפּ- זיכערע פֿראגן קעגן די טישן:

	for (Record2<String, String> record : DSL.using(configuration)
//   ^^^^^^^^^^^^^^^^^^^^^^^ Информация о типах выведена на 
//   основании сгенерированного кода, на который ссылается приведенное
// ниже условие SELECT 
 
       .select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME)
//           vvvvv ^^^^^^^^^^^^  ^^^^^^^^^^^^^^^ сгенерированные имена
       .from(ACTOR)
       .orderBy(1, 2)) {
    // ...
}

דער קאָד איז דזשענערייטאַד אָדער מאַניואַלי אַרויס פון די בויען, אָדער מאַניואַלי אויף יעדער בויען. פֿאַר בייַשפּיל, אַזאַ רידזשענעריישאַן קען נאָכפאָלגן מיד נאָך פליווייַ דאַטאַבייס מיגראַטיאָן, וואָס קענען אויך זיין מאַניואַלי אָדער אויטאָמאַטיש.

מקור קאָד דור

עס זענען פאַרשידן פילאָסאָפיעס, אַדוואַנטידזשיז און דיסאַדוואַנטידזשיז פֿאַרבונדן מיט די אַפּראָוטשיז צו קאָד דור - מאַנואַל און אָטאַמאַטיק - וואָס איך בין נישט געגאנגען צו דיסקוטירן אין דעטאַל אין דעם אַרטיקל. אָבער, אין אַלגעמיין, די גאנצע פונט פון די דזשענערייטאַד קאָד איז אַז עס אַלאַוז איר צו רעפּראָדוצירן אין Java די "אמת" וואָס מיר נעמען פֿאַר געגעבן, אָדער אין אונדזער סיסטעם אָדער אַרויס עס. אין אַ זינען, קאָמפּילערס וואָס דזשענערייט בייטעקאָוד, מאַשין קאָד אָדער עטלעכע אנדערע סאָרט פון קאָד פון מקור קאָד טאָן די זעלבע זאַך - מיר באַקומען אַ פאַרטרעטונג פון אונדזער "אמת" אין אן אנדער שפּראַך, ראַגאַרדלאַס פון ספּעציפיש סיבות.

עס זענען פילע אַזאַ קאָד גענעראַטאָרס. למשל, XJC קענען דזשענערייט Java קאָד באזירט אויף XSD אָדער WSDL טעקעס. דער פּרינציפּ איז שטענדיק דער זעלביקער:

• עס איז עטלעכע אמת (ינערלעך אָדער פונדרויסנדיק) - פֿאַר בייַשפּיל, אַ באַשרייַבונג, אַ דאַטן מאָדעל, אאז"ו ו.
• מיר דאַרפֿן אַ היגע פאַרטרעטונג פון דעם אמת אין אונדזער פּראָגראַממינג שפּראַך.

דערצו, עס איז כּמעט שטענדיק קעדייַיק צו דזשענערייט אַזאַ אַ פאַרטרעטונג - אין סדר צו ויסמיידן יבעריקייַט.

טיפּ פּראַוויידערז און אַנאַטיישאַן פּראַסעסינג

באַמערקונג: אן אנדער, מער מאָדערן און ספּעציפיש צוגאַנג צו דזשענערייטינג קאָד פֿאַר jOOQ ינוואַלווז די נוצן פון טיפּ פּראַוויידערז, ווי זיי זענען ימפּלאַמענאַד אין F #. אין דעם פאַל, די קאָד איז דזשענערייטאַד דורך די קאַמפּיילער, אַקשלי אין די זאַמלונג בינע. אין פּרינציפּ, אַזאַ קאָד טוט נישט עקסיסטירן אין די פאָרעם פון מקור קאָודז. אין Java, עס זענען ענלעך מכשירים, כאָטש ניט ווי עלעגאַנט - דאָס זענען אַנאַטיישאַן פּראַסעסערז, למשל, לאָמבאָק.

אין אַ געוויסן זינען, די זעלבע זאכן פּאַסירן דאָ ווי אין דער ערשטער פאַל, אַחוץ:

• איר טאָן ניט זען די דזשענערייטאַד קאָד (אפֿשר די סיטואַציע איז נישט אַזוי ריפּאַלסיוו פֿאַר עמעצער?)
• איר מוזן ענשור אַז טייפּס קענען זיין צוגעשטעלט, דאָס איז, "אמת" מוזן שטענדיק זיין בנימצא. דאָס איז גרינג אין דעם פאַל פון לאָמבאָק, וואָס אַנאַטייט "אמת". עס איז אַ ביסל מער שווער מיט דאַטאַבייס מאָדעלס וואָס אָפענגען אויף אַ לעבן קשר וואָס איז שטענדיק בנימצא.

וואָס איז די פּראָבלעם מיט די פּראָדוקציע פון ​​קאָד?

אין אַדישאַן צו די טריקי קשיא פון ווי עס איז בעסער צו אָנהייבן קאָד דזשענערייטינג - מאַניואַלי אָדער אויטאָמאַטיש, איך האָבן צו דערמאָנען אַז עס זענען מענטשן וואָס גלויבן אַז קאָד דור איז נישט דארף. די טערעץ פֿאַר דעם פונט פון מיינונג, וואָס איך געפֿונען רובֿ אָפט, איז אַז עס איז שווער צו שטעלן די בויען רערנ - ליניע. יא, עס איז טאַקע שווער. עס זענען נאָך ינפראַסטראַקטשער קאָס. אויב איר נאָר אָנהייבן מיט אַ באַזונדער פּראָדוקט (זיין עס jOOQ, אָדער JAXB, אָדער Hibernate, אאז"ו ו), עס נעמט צייט צו שטעלן אַ וואָרקבענטש וואָס איר וואָלט ווי צו פאַרברענגען צו לערנען די API זיך צו באַקומען ווערט פון עס. .

אויב די קאָס פֿאַר די פארשטאנד פון די גענעראַטאָר מיטל זענען צו הויך, טאַקע, די API האט אַ נעבעך אַרבעט אויף די וסאַביליטי פון די קאָד גענעראַטאָר (און אין דער צוקונפֿט עס טורנס אויס אַז קוסטאָמיזאַטיאָן אין עס איז אויך שווער). וסאַביליטי זאָל זיין די העכסטן בילכערקייַט פֿאַר אַזאַ אַפּי. אָבער דאָס איז בלויז איין אַרגומענט קעגן די דור פון קאָד. אַנדערש, שרייַבן לעגאַמרע דורך האַנט די היגע פאַרטרעטונג פון ינערלעך אָדער פונדרויסנדיק אמת.

פילע וועלן זאָגן אַז זיי טאָן ניט האָבן צייַט צו טאָן אַלע דעם. זיי זענען אויף טערמין פֿאַר זייער סופּער פּראָדוקט. אַמאָל שפּעטער מיר וועלן קאַם די פֿאַרזאַמלונג קאַנווייערז, מיר וועלן האָבן צייַט. איך וועל זיי ענטפערן:

אָריגינעל, Alan O'Rourke, וילעם סטאַק

אָבער אין Hibernate / JPA עס איז אַזוי גרינג צו שרייַבן קאָד "אין דזשאַוואַ".

טאַקע. פֿאַר Hibernate און זיין יוזערז, דאָס איז ביידע אַ ברכה און אַ קללה. אין Hibernate, איר קענען פשוט שרייַבן אַ פּאָר פון ענטיטיז, ווי דאָס:

	@Entity
class Book {
  @Id
  int id;
  String title;
}

און כּמעט אַלץ איז גרייט. איצט די פּלאַץ פון כייבערנייט איז צו דזשענערייט קאָמפּלעקס "דעטאַילס" פון ווי פּונקט דעם ענטיטי וועט זיין דיפיינד אין די DDL פון דיין "דיאַלעקט" פון SQL:

	CREATE TABLE book (
  id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
  title VARCHAR(50),
 
  CONSTRAINT pk_book PRIMARY KEY (id)
);
 
CREATE INDEX i_book_title ON book (title);

... און אָנהייבן פליסנדיק די אַפּלאַקיישאַן. א טאַקע קיל שטריך צו באַקומען אַרויף און פליסנדיק געשווינד און פּרובירן פאַרשידענע טינגז.

אָבער, לאָזן מיר. איך בין געלעגן.

• וועט Hibernate אַקשלי דורכפירן די דעפֿיניציע פון ​​דעם געהייסן ערשטיק שליסל?
• וועט Hibernate שאַפֿן אַן אינדעקס אויף TITLE? איך וויסן פֿאַר זיכער מיר דאַרפֿן עס.
• וועט Hibernate מאַכן דעם שליסל אַ אידענטיטעט שליסל אין די אידענטיטעט ספּעסיפיקאַטיאָן?

מסתּמא נישט. אויב איר אַנטוויקלען דיין פּרויעקט פֿון קראַצן, עס איז שטענדיק באַקוועם צו פשוט אַוועקוואַרפן די אַלט דאַטאַבייס און דזשענערייט אַ נייַע ווי באַלד ווי איר לייגן די נייטיק אַנאַטיישאַנז. אַזוי, דער ספר ענטיטי וועט יווענטשאַוואַלי נעמען די פאָרעם:

	@Entity
@Table(name = "book", indexes = {
  @Index(name = "i_book_title", columnList = "title")
})
class Book {
  @Id
  @GeneratedValue(strategy = IDENTITY)
  int id;
  String title;
}

קיל. רידזשענערייט. ווידער, אין דעם פאַל, עס וועט זיין זייער גרינג אין די אָנהייב.

אבער איר וועט האָבן צו באַצאָלן פֿאַר אים שפּעטער.

גיכער אָדער שפּעטער איר וועט האָבן צו גיין אין פּראָדוקציע. אַז ס ווען די מאָדעל סטאַפּס ארבעטן. ווייַל:

אין פּראָדוקציע, עס וועט ניט מער זיין מעגלעך, אויב נייטיק, אַוועקוואַרפן די אַלט דאַטאַבייס און אָנהייבן אַלץ פֿון קראַצן. דיין דאַטאַבייס וועט ווערן אַ לעגאַט.

פֿון איצט און אויף אייביק וועט איר האָבן צו שרייַבן DDL מיגראַטיאָן סקריפּס, למשל ניצן Flyway. און וואָס וועט פּאַסירן מיט דיין ענטיטיז אין דעם פאַל? איר קענען אָדער שניידן זיי מאַניואַלי (און טאָפּל דיין ווערקלאָוד) אָדער הייבערנייט רידזשענערייטיד זיי פֿאַר איר (ווי מסתּמא איז דער איינער דזשענערייטאַד אויף דעם וועג צו טרעפן דיין עקספּעקטיישאַנז?) איר פאַרלירן יעדער וועג.

אזוי, ווי באַלד ווי איר מאַך אין פּראָדוקציע, איר וועט דאַרפֿן הייס פּאַטשאַז. און זיי דאַרפֿן צו זיין געבראכט צו פּראָדוקציע זייער געשווינד. זינט איר האָט נישט צוגעגרייט און אָרגאַניזירט אַ גלאַט פּייפּליין פון דיין מייגריישאַנז פֿאַר פּראָדוקציע, איר פּאַטשינג ווילד. און דעמאָלט איר טאָן ניט האָבן צייַט צו טאָן אַלץ רעכט. און איר באַשולדיקן כייבערנייט, ווייַל עס איז שטענדיק ווער עס יז ס שולד, אָבער נישט איר ...

אדרבה, פון אנהייב האט מען אלץ געקענט טאן גאר אנדערש. פֿאַר בייַשפּיל, שטעלן קייַלעכיק ווילז אויף אַ וועלאָסיפּעד.

דאַטאַבאַסע ערשטער

דער עמעס "אמת" אין דיין דאַטאַבייס סטשעמאַ און "סאַווראַנטי" איבער עס ליגט אין די דאַטאַבייס. די סטשעמאַ איז דיפיינד בלויז אין די דאַטאַבייס זיך און ינ ערגעצ ניט אַנדערש, און יעדער פון די קלייאַנץ האט אַ קאָפּיע פון ​​דעם סטשעמאַ, אַזוי עס מאכט אַ גאנץ זינען צו דורכפירן די אַדכיראַנס צו די סטשעמאַ און זייַן אָרנטלעכקייַט, צו טאָן דאָס רעכט אין די דאַטאַבייס - ווו אינפֿאָרמאַציע איז סטאָרד.
דאָס איז אַלט אַפֿילו האַקנעד חכמה. ערשטיק און יינציק שליסלען זענען גוט. פרעמד שליסלען זענען גוט. קאַנסטריינץ קאָנטראָלירונג איז גוט. אַסערשאַנז - פייַן.

און, דאָס איז נישט אַלע. פֿאַר בייַשפּיל, ניצן אָראַקלע, איר וואָלט מיסטאָמע ווילן צו ספּעציפיצירן:

• אין וואָס טיש פּלאַץ איז דיין טיש
• וואָס איז איר PCTFREE ווערט
• וואָס איז די קאַש גרייס אין דיין סיקוואַנס (הינטער די שייַן)

אַלע דעם קען נישט ענין אין קליין סיסטעמען, אָבער עס איז ניט נייטיק צו וואַרטן ביז די יבערגאַנג צו די מעלוכע פון ​​"גרויס דאַטן" - איר קענען אָנהייבן צו נוץ פון פאַרקויפער-צוגעשטעלט סטאָרידזש אָפּטימיזאַטיאָנס, אַזאַ ווי די דערמאנט אויבן, פיל פריער. קיינער פון די אָרמס איך ווע געזען (אַרייַנגערעכנט jOOQ) צושטעלן אַקסעס צו די פול גאַנג פון DDL אָפּציעס וואָס איר זאל וועלן צו נוצן אין דיין דאַטאַבייס. ORMs פאָרשלאָגן עטלעכע מכשירים צו העלפן איר שרייַבן DDL.

אבער אין די סוף פון די טאָג, אַ געזונט-דיזיינד סטשעמאַ איז האַנט-געשריבן אין DDL. קיין דזשענערייטאַד DDL איז בלויז אַן אַפּראַקסאַמיישאַן פון עס.

וואָס וועגן דעם קליענט מאָדעל?

ווי דערמאנט אויבן, אויף דעם קליענט איר דאַרפֿן אַ קאָפּיע פון ​​​​דיין דאַטאַבייס סטשעמאַ, דער קליענט מיינונג. יבעריק צו זאָגן, דעם קליענט מיינונג מוזן זיין סינק מיט די פאַקטיש מאָדעל. וואָס איז דער בעסטער וועג צו דערגרייכן דעם? מיט אַ קאָד גענעראַטאָר.

כל דאַטאַבייסיז צושטעלן זייער מעטאַ אינפֿאָרמאַציע דורך סקל. דאָ ס ווי צו באַקומען אַלע טישן אין פאַרשידענע סקל דייאַלעקץ פֿון דיין דאַטאַבייס:

	-- H2, HSQLDB, MySQL, PostgreSQL, SQL Server
SELECT table_schema, table_name
FROM information_schema.tables
 
-- DB2
SELECT tabschema, tabname
FROM syscat.tables
 
-- Oracle
SELECT owner, table_name
FROM all_tables
 
-- SQLite
SELECT name
FROM sqlite_master
 
-- Teradata
SELECT databasename, tablename
FROM dbc.tables

די פֿראגן (אָדער ענלעך אָנעס, דיפּענדינג אויף צי איר אויך האָבן צו באַטראַכטן קוקן, מאַטיריאַלייזד קוקן, טיש-וואַליוד פאַנגקשאַנז) זענען אויך עקסאַקיוטאַד דורך פאַך DatabaseMetaData.getTables() פֿון JDBC, אָדער ניצן די jOOQ מעטאַ-מאָדולע.

פֿון די רעזולטאַטן פון אַזאַ פֿראגן, עס איז לעפיערעך גרינג צו דזשענערייט קיין פאַרטרעטונג אויף דער קליענט זייַט פון דיין דאַטאַבייס מאָדעל, קיין ענין וואָס טעכנאָלאָגיע איר נוצן אויף דעם קליענט.

• אויב איר נוצן JDBC אָדער Spring, איר קענען מאַכן אַ גאַנג פון שטריקל קאַנסטאַנץ
• אויב איר נוצן JPA, איר קענען דזשענערייט די ענטיטיז זיך
• אויב איר נוצן jOOQ, איר קענען דזשענערייט jOOQ מעטאַ מאָדעל

דעפּענדינג אויף ווי פיל פיייקייט דיין קליענט אַפּי אָפפערס (למשל jOOQ אָדער JPA), די דזשענערייטאַד מעטאַ מאָדעל קענען זיין טאַקע רייַך און גאַנץ. נעמען, פֿאַר בייַשפּיל, די מעגלעכקייט פון ימפּליסאַט דזשוינץ, באַקענענ אין jOOQ 3.11, וואָס רילייז אויף דזשענערייטאַד מעטאַ-אינפֿאָרמאַציע וועגן פרעמד שליסל באציונגען צווישן דיין טישן.

איצט קיין דאַטאַבייס ינקראַמאַנט וועט אויטאָמאַטיש דערהייַנטיקן דעם קליענט קאָד. ימאַדזשאַן פֿאַר בייַשפּיל:

ALTER TABLE book RENAME COLUMN title TO book_title;

וואָלט איר טאַקע ווי צו טאָן דעם אַרבעט צוויי מאָל? אין קיין פאַל. מיר נאָר טוען די DDL, לויפן עס דורך דיין בויען רערנ - ליניע און באַקומען די דערהייַנטיקט ענטיטי:

@Entity
@Table(name = "book", indexes = {
 
  // Вы об этом задумывались?
  @Index(name = "i_book_title", columnList = "book_title")
})
class Book {
  @Id
  @GeneratedValue(strategy = IDENTITY)
  int id;
 
  @Column("book_title")
  String bookTitle;
}

אָדער דער דערהייַנטיקט jOOQ קלאַס. רובֿ DDL ענדערונגען אויך ווירקן סעמאַנטיקס, ניט נאָר סינטאַקס. דעריבער, עס קען זיין באַקוועם צו זען אין די קאַמפּיילד קאָד וואָס קאָד וועט (אָדער קען זיין) אַפעקטאַד דורך ינקראַמאַנטינג דיין דאַטאַבייס.

דער איינציקער אמת

ראַגאַרדלאַס פון וואָס טעכנאָלאָגיע איר נוצן, עס איז שטענדיק איין מאָדעל וואָס איז דער בלויז מקור פון אמת פֿאַר עטלעכע סאַבסיסטאַמז - אָדער בייַ מינדסטער מיר זאָל שטרעבן פֿאַר דעם און ויסמיידן פאַרנעמונג צעמישונג ווו "אמת" איז אומעטום און ינ ערגעצ ניט אין אַמאָל. אַלץ קען זיין פיל גרינגער. אויב איר נאָר וועקסל XML טעקעס מיט עטלעכע אנדערע סיסטעם, נאָר נוצן XSD. קוק אין jOOQ ס INFORMATION_SCHEMA מעטאַ-מאָדעל אין קסמל פאָרעם:
https://www.jooq.org/xsd/jooq-meta-3.10.0.xsd

• XSD איז גוט פארשטאנען
• XSD מאַרקז XML אינהאַלט זייער גוט און אַלאַוז וואַלאַדיישאַן אין אַלע קליענט שפּראַכן
• XSD איז געזונט ווערסיע און העכסט קאַפּויער קאַמפּאַטאַבאַל
• XSD קענען זיין איבערגעזעצט אין Java קאָד מיט XJC

די לעצטע פונט איז וויכטיק. ווען קאַמיונאַקייטינג מיט אַ פונדרויסנדיק סיסטעם ניצן קסמל אַרטיקלען, מיר ווילן צו זיין זיכער אַז אונדזער אַרטיקלען זענען גילטיק. דאָס איז זייער גרינג צו דערגרייכן מיט JAXB, XJC און XSD. עס וואָלט זיין לויטער מעשוגאַס צו טראַכטן אַז, אין אַ Java-ערשטער פּלאַן צוגאַנג, ווו מיר מאַכן אונדזער אַרטיקלען ווי Java אַבדזשעקץ, זיי קען עפעס זיין רענדערד ינטעלידזשאַבלי צו XML און געשיקט פֿאַר קאַנסאַמשאַן צו אן אנדער סיסטעם. די קסמל דזשענערייטאַד אין דעם וועג וואָלט זיין פון זייער נעבעך קוואַליטעט, אַנדאַקיאַמעניד און שווער צו אַנטוויקלען. אויב עס איז געווען אַ העסקעם אויף דער מדרגה פון דינסט קוואַליטעט (SLA) אויף אַזאַ אַ צובינד, מיר וואָלט מיד שרויף עס.

צו זיין ערלעך, דאָס איז פּונקט וואָס כאַפּאַנז אַלע מאָל מיט די JSON API, אָבער דאָס איז אן אנדער געשיכטע, איך וועט טייַנען ווייַטער מאָל ...

דאַטאַבייסיז: זיי זענען די זעלבע

ארבעטן מיט דאַטאַבייסיז, איר פֿאַרשטיין אַז זיי זענען אַלע בייסיקלי די זעלבע. די דאַטאַבייס אָונז זייַן דאַטן און מוזן פירן די סטשעמאַ. כל מאָדיפיקאַטיאָנס געמאכט צו די סטשעמאַ מוזן זיין ימפּלאַמענאַד גלייַך אין DDL אַזוי אַז די איין מקור פון אמת איז דערהייַנטיקט.

ווען דער מקור דערהייַנטיקן איז פארגעקומען, אַלע קלייאַנץ מוזן אויך דערהייַנטיקן זייער קאָפּיעס פון די מאָדעל. עטלעכע קלייאַנץ קען זיין געשריבן אין Java ניצן jOOQ און Hibernate אָדער JDBC (אָדער ביידע). אנדערע קלייאַנץ קענען זיין געשריבן אין פּערל (לאָמיר ווינטשן זיי גליק), אנדערע אין C #. עס טוט נישט ענין. דער הויפּט מאָדעל איז אין די דאַטאַבייס. ORM-דזשענערייטאַד מאָדעלס זענען יוזשאַוואַלי פון נעבעך קוואַליטעט, שוואַך דאַקיומענטאַד און שווער צו אַנטוויקלען.

אַזוי טאָן ניט מאַכן מיסטייקס. דו זאלסט נישט מאַכן מיסטייקס פון די אָנהייב. אַרבעט פֿון אַ דאַטאַבייס. בויען אַ דיפּלוימאַנט רערנ - ליניע וואָס קענען זיין אָטאַמייטיד. געבן קאָד גענעראַטאָרס צו קאַנוויניאַנטלי נאָכמאַכן דיין דאַטאַבייס מאָדעל און דאַמפּ עס אויף קלייאַנץ. און האַלטן זאָרג וועגן קאָד גענעראַטאָרס. זיי זענען גוט. מיט זיי, איר וועט ווערן מער פּראָדוקטיוו. כל איר דאַרפֿן צו טאָן איז צו פאַרברענגען אַ ביסל צייט צו באַשטעטיקן זיי גלייך פֿון די אָנהייב, און איר וועט האָבן יאָרן פון ימפּרוווד פאָרשטעלונג צו בויען דיין פּרויעקט ס געשיכטע.

דאנק מיר נאך נישט, שפעטער.

קלעראַפאַקיישאַן

צו זיין קלאָר: דער אַרטיקל טוט נישט אַדוואָקאַט אין קיין וועג אַז די גאנצע סיסטעם (ד"ה פעלד, געשעפט לאָגיק, אאז"ו ו, אאז"ו ו) דאַרף זיין פלעקסיד צו פּאַסיק דיין דאַטאַבייס מאָדעל. וואָס איך רעדן וועגן אין דעם אַרטיקל איז אַז קליענט קאָד וואָס ינטעראַקץ מיט אַ דאַטאַבייס זאָל זיין אַקט אויף די יקער פון די דאַטאַבייס מאָדעל אַזוי אַז עס קען נישט רעפּראָדוצירן די דאַטאַבייס מאָדעל אין "ערשטער קלאַס" סטאַטוס. אַזאַ לאָגיק איז יוזשאַוואַלי ליגן אין די דאַטן אַקסעס שיכטע אויף דיין קליענט.

אין צוויי-שטאַפּל אַרקאַטעקטשערז, וואָס זענען נאָך אפגעהיט אין עטלעכע ערטער, אַזאַ אַ סיסטעם מאָדעל קען זיין דער בלויז מעגלעך. אָבער, אין רובֿ סיסטעמען, די דאַטן אַקסעס שיכטע מיינט צו מיר אַ "סובסיסטעם" וואָס ענקאַפּסאַלייץ די דאַטאַבייס מאָדעל.

Exceptions

עס זענען אויסנעמען צו יעדער הערשן, און איך האָבן געזאָגט פריער אַז די דאַטאַבייס ערשטער און מקור קאָד דור צוגאַנג קענען מאל זיין ינאַפּראָופּרייט. דאָ זענען אַ פּאָר פון אַזאַ אויסנעמען (עס זענען מיסטאָמע אנדערע):

• ווען די סטשעמאַ איז אומבאַקאַנט און דאַרף זיין געעפנט. פֿאַר בייַשפּיל, איר צושטעלן אַ געצייַג צו העלפֿן ניצערס צו נאַוויגירן קיין דיאַגראַמע. פיי. עס איז קיין קאָד דור דאָ. אבער נאָך - די דאַטאַבאַסע ערשטער פון אַלע.
• ווען אַ קרייַז דאַרף זיין דזשענערייטאַד אויף די פליען צו סאָלווע עטלעכע פּראָבלעם. דער בייַשפּיל מיינט צו זיין אַ ביסל פרילי ווערסיע פון ​​​​דעם מוסטער ענטיטי אַטריביוט ווערט, ד"ה איר טאָן ניט טאַקע האָבן אַ געזונט-דיפיינד סטשעמאַ. אין דעם פאַל, איר אָפט קען נישט זיין זיכער אַז אַ RDBMS וועט פּאַסן איר.

אויסנעמען זענען פון נאַטור יקסעפּשאַנאַל. אין רובֿ פאלן מיט די נוצן פון RDBMS, די סטשעמאַ איז באקאנט אין שטייַגן, עס איז ין די RDBMS און איז דער בלויז מקור פון "אמת", און אַלע קלייאַנץ האָבן צו קריגן קאָפּיעס דערייווד פון עס. ידעאַללי, דאָס זאָל אַרייַנציען אַ קאָד גענעראַטאָר.

מקור: www.habr.com