جے پی اے اداروں اور ڈی بی تعلقات

جے پی اے اداروں اور ڈی بی تعلقات

اچھا دن، ساتھیوں! یہ مواد ان لوگوں کے لیے ہے جو پہلے سے ڈیٹا بیس کی تنظیم کے بارے میں سمجھتے ہیں (اس کے بعد صرف DB - "Database")، کم سے کم علم ہے کہ کس طرح آبجیکٹ-ریلیشنل میپنگ کام کرتی ہے (اس کے بعد صرف ORM )، اور اس کے نفاذ، جیسے Hibernate/JPA . اگر آپ اس سے واقف نہیں ہیں، تو میں آپ کو مشورہ دیتا ہوں کہ JDBC سے شروعات کریں ، اور اس کے بعد ہی ORM ماڈل پر جائیں۔ میں نے آپ کو خبردار کیا تھا، اور میں مناسب تیاری کے بغیر اس مضمون کو پڑھنے کے بعد آپ کی نفسیات کا ذمہ دار نہیں ہوں! :) کی ترتیب میں سب کچھ کے ساتھ نمٹنے کے لئے شروع کرتے ہیں. سب سے پہلے، ہم تھیوری میں تھوڑا سا دھیان دیں گے، تھوڑا سا۔ دوم، ہم یہ معلوم کریں گے کہ ہر کسی کے پسندیدہ جاوا میں اس گندگی کو کیسے کرنا ہے۔ ہم آپ کے ساتھ ایک پراجیکٹ-چیٹ شیٹ بھی لکھیں گے، جو موضوع کے بارے میں ہماری سمجھ کو مضبوط کرے گی اور نقشہ سازی کیسے کی جانی چاہیے کے لیے ایک ٹیمپلیٹ کے طور پر کام کرے گی ۔ تو، چلو یہ کرتے ہیں!

ہستی کیا ہے؟

ایک ہستی حقیقی زندگی سے ایک شے ہے (مثال کے طور پر، ایک کار) جس میں صفات (دروازے، پہیے ، انجن) ہوتے ہیں۔ ڈی بی ہستی: اس صورت میں، ہماری ہستی ڈی بی میں محفوظ ہے، سب کچھ آسان ہے۔ ہم نے کار کو ڈیٹا بیس میں کیوں اور کیسے ڈالا - ہم اسے بعد میں دیکھیں گے۔

ڈی بی تعلقات کیا ہے؟

ایک طویل عرصہ پہلے، دور دراز سلطنت میں ، ایک رشتہ دار ڈی بی بنایا گیا تھا ۔ اس ڈی بی میں ڈیٹا کو ٹیبل کی شکل میں پیش کیا گیا تھا۔ لیکن Shrek سے گدھا بھی سمجھ گیا کہ ان میزوں کو آپس میں جوڑنے کے لیے ایک طریقہ کار بنانا ضروری ہے۔ نتیجے کے طور پر، 4 DB تعلقات ظاہر ہوئے :

1. ون ٹو ون
2. ایک سے کئی
3. کئی سے ایک
4. کئی سے کئی

اگر آپ یہ سب پہلی بار دیکھ رہے ہیں، تو میں آپ کو دوبارہ خبردار کرتا ہوں - یہ مزید خراب ہو جائے گا: سیر کے لیے جانے کے بارے میں سوچیں۔ ہم ایک مثال کے ذریعے ان تمام رشتوں کا تجزیہ کریں گے، اور ان کے درمیان فرق کو سمجھیں گے۔

خوفناک مثال

ہمارے پاس ایک پروجیکٹ ہوگا جس کی 5 شاخیں ہوں گی: ماسٹر، جہاں پروجیکٹ کی تفصیل ہوگی، اور ہر DB تعلق کے لیے 1 برانچ۔ ہر برانچ میں ڈی بی بنانے اور اسے ٹیسٹ ڈیٹا سے بھرنے کے لیے ایس کیو ایل اسکرپٹس کے علاوہ تشریحی نقشہ سازی کے ساتھ ایک ہستی کی کلاس ہوگی۔ ہر برانچ کے لیے ایک ہائبرنیٹ کنفگ فائل بھی ہوگی۔ میں پروجیکٹ کے لیے H2 ایمبیڈڈ DB استعمال کروں گا تاکہ کلاؤڈ DB یا بیرونی DB کے انفرادی پہلوؤں سے مشغول نہ ہوں۔ لنک پر عمل کرتے ہوئے، اپنے ویکیوم کلینر پر H2 DB انسٹال کریں۔ میں ہر قدم کو 1 برانچ میں بیان کروں گا، باقی صرف اہم نکات ہیں۔ آخر میں ہم خلاصہ کریں گے۔ جاؤ. یہ میرے پروجیکٹ کی ماسٹر برانچ کا لنک ہے۔

ون ٹو ون رشتہ

یہاں برانچ سے لنک کریں ۔

1. ہمیں اپنے پروجیکٹ سے H2 DB کو جوڑنے کی ضرورت ہے۔ یہاں ہمیں اس بات پر زور دینے کی ضرورت ہے کہ ہمیں DB اور دیگر چیزوں کے ساتھ آرام سے کام کرنے کے لیے Ultimate IDEA کی ضرورت ہے۔ اگر آپ کے پاس پہلے سے ہی ہے، تو براہ راست DB کنکشن پر جائیں۔ ڈیٹا بیس ٹیب پر جائیں اور اسکرین شاٹ کی طرح کریں:

   اگلا ہم DB کی ترتیبات پر جاتے ہیں۔ آپ اپنا ڈیٹا، اور یہاں تک کہ اپنا DBMS بھی درج کر سکتے ہیں؛ میں دہراتا ہوں، میں سادگی کے لیے H2 DB استعمال کرتا ہوں۔

   اگلا، سرکٹ قائم کرتے ہیں. یہ مرحلہ اختیاری ہے لیکن اگر آپ کے پاس DB میں متعدد اسکیمے ہیں تو اس کی سفارش کی جاتی ہے۔

   ترتیبات کو لاگو کریں، اور آخر میں ہمیں کچھ اس طرح ملنا چاہئے:

2. ہم نے ڈیٹا بیس بنایا اور IDEA سے اس تک رسائی کو ترتیب دیا۔ اب آپ کو اس میں ٹیبل بنانے اور کچھ ڈیٹا سے بھرنے کی ضرورت ہے۔ مثال کے طور پر، میں دو اداروں کو لوں گا: مصنف اور کتاب۔ ایک کتاب کا ایک مصنف ہو سکتا ہے، ایک سے زیادہ مصنفین ہو سکتے ہیں، یا ہو سکتا ہے کہ ایک نہ ہو۔ اس مثال میں ہم ہر قسم کے کنکشن بنائیں گے۔ لیکن اس وقت - ون ٹو ون رشتہ۔ آئیے متعلقہ اسکرپٹ بنائیں جو ڈی بی ٹیبلز بناتی ہے :

   DROP TABLE IF EXISTS PUBLIC.BOOK;
   
   CREATE TABLE PUBLIC.BOOK (
     ID         INTEGER      NOT NULL AUTO_INCREMENT,
     NAME       VARCHAR(255) NOT NULL,
     PRINT_YEAR INTEGER(4)   NOT NULL,
     CONSTRAINT BOOK_PRIMARY_KEY PRIMARY KEY (ID)
   );
   
   DROP TABLE IF EXISTS PUBLIC.AUTHOR;
   
   CREATE TABLE PUBLIC.AUTHOR (
     ID          INTEGER      NOT NULL AUTO_INCREMENT,
     FIRST_NAME  VARCHAR(255) NOT NULL,
     SECOND_NAME VARCHAR(255) NOT NULL,
     BOOK_ID     INTEGER      NOT NULL UNIQUE,
     CONSTRAINT AUTHOR_PRIMARY_KEY PRIMARY KEY (ID),
     CONSTRAINT BOOK_FOREIGN_KEY FOREIGN KEY (BOOK_ID) REFERENCES BOOK (ID)
   );

   اور آئیے اس پر عمل کریں:

   کنسول میں عملدرآمد کا نتیجہ:

   DB میں نتیجہ:

3. آئیے اپنی میزوں کا خاکہ دیکھتے ہیں۔ ایسا کرنے کے لیے، ہمارے DB پر RMB:

   نتیجہ:

   UML ڈایاگرام پر ہم تمام بنیادی کلیدیں اور غیر ملکی کیز دیکھ سکتے ہیں، ہم اپنی میزوں کے درمیان کنکشن بھی دیکھتے ہیں۔

4. آئیے ایک اسکرپٹ لکھیں جو ہمارے ڈی بی کو ٹیسٹ ڈیٹا سے بھرے:

   INSERT INTO PUBLIC.BOOK (NAME, PRINT_YEAR)
   VALUES ('First book', 2010),
          ('Second book', 2011),
          ('Third book', 2012);
   
   INSERT INTO PUBLIC.AUTHOR (FIRST_NAME, SECOND_NAME, BOOK_ID)
   VALUES ('Pablo', 'Lambado', 1),
          ('Pazo', 'Zopa', 2),
          ('Lika', 'Vika', 3);

   میرا مطلب ہے، کیا ہوتا ہے؟ ون ٹو ون تعلقات کی ضرورت اس وقت ہوتی ہے جب ایک ٹیبل کی ہستی دوسرے کی ایک ہستی سے متعلق ہو (یا اگر BOOK_ID سے NULL کو ہٹا دیا گیا ہو تو بالکل بھی متعلق نہیں)۔ ہماری مثال میں، ایک کتاب کا ایک مصنف ہونا چاہیے۔ کوئی دوسرا راستہ نہیں۔

5. اب سب سے دلچسپ بات یہ ہے کہ جاوا کلاس کو DB اداروں کے ساتھ کیسے جوڑا جائے؟ بہت آسان. آئیے کتاب اور مصنف کی دو کلاسیں بنائیں۔ ایک مثال کا استعمال کرتے ہوئے، میں کلاس 1 اور اہم مواصلاتی شعبوں کا تجزیہ کروں گا۔ آئیے مصنف کی کلاس کو بطور مثال لیتے ہیں :

   @Data
   @Entity
   @DynamicInsert
   @DynamicUpdate
   @Table(name = "AUTHOR")
   public class Author {
   
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       @Column(name = "ID", nullable = false)
       private Long id;
   
       @Column(name = "FIRST_NAME", nullable = false)
       private String firstName;
   
       @Column(name = "SECOND_NAME", nullable = false)
       private String secondName;
   
       @OneToOne
       @JoinColumn(name = "BOOK_ID", unique = true, nullable = false)
       private Book book;
   }

آئیے اسے ترتیب سے معلوم کریں:

1. کلاس کے تمام فیلڈز DB ہستی کی صفات کو دہراتے ہیں۔
2. @Data ( لومبوک سے ) کا کہنا ہے کہ ہر فیلڈ کے لیے ایک گیٹر اور سیٹر بنایا جائے گا، برابر، ہیش کوڈ کو اوور رائیڈ کیا جائے گا، اور ایک toString طریقہ تیار کیا جائے گا۔
3. @Entity کا کہنا ہے کہ دی گئی کلاس ایک ہستی ہے اور DB ہستی سے وابستہ ہے۔
4. @DynamicInsert اور @DynamicUpdate کا کہنا ہے کہ DB میں ڈائنامک انسرٹس اور اپ ڈیٹس کیے جائیں گے۔ یہ گہری ہائبرنیٹ سیٹنگز ہیں جو آپ کے لیے کارآمد ہوں گی تاکہ آپ کے پاس صحیح بیچنگ ہو۔
5. @ٹیبل (نام = "AUTHOR") کتاب کی کلاس کو DB AUTHOR ٹیبل سے جوڑتا ہے۔
6. @Id کہتا ہے کہ یہ فیلڈ بنیادی کلید ہے۔
7. @GeneratedValue (حکمت عملی = GenerationType.IDENTITY) - بنیادی کلیدی نسل کی حکمت عملی۔
8. @Column (name = "ID", nullable = false) ایک فیلڈ کو DB وصف کے ساتھ منسلک کرتا ہے، اور یہ بھی کہتا ہے کہ دی گئی DB فیلڈ کو کالعدم نہیں کیا جا سکتا۔ اداروں سے ٹیبل تیار کرتے وقت یہ بھی مفید ہے۔ اب ہم اپنا پروجیکٹ کیسے بناتے ہیں اس کے الٹ عمل، یونٹ ٹیسٹ کے لیے ٹیسٹ DBs میں اس کی ضرورت ہے۔
9. @OneToOne کا کہنا ہے کہ دی گئی فیلڈ ایک سے ایک رشتہ والی فیلڈ ہے۔
10. @JoinColumn (نام = "BOOK_ID", unique = true, nullable = false) - ایک BOOK_ID کالم بنایا جائے گا، جو منفرد ہے اور کالعدم نہیں ہے۔

الٹ سائیڈ پر ( کتاب کی کلاس میں ) ہمیں ون ٹو ون کنکشن بنانے اور اس فیلڈ کی نشاندہی کرنے کی ضرورت ہے جس پر میپنگ ہوتی ہے۔ @OneToOne(mappedBy = "book") - اس مثال میں، یہ مصنف کی کلاس کا بک فیلڈ ہے۔ جے پی اے انہیں خود جوڑ دے گا۔ پہلی نظر میں، ایسا لگتا ہے کہ تشریحات کی گڑبڑ ہے، لیکن حقیقت میں یہ بہت آسان ہے اور تجربے کے ساتھ آپ بغیر سوچے سمجھے خود بخود انہیں شامل کر لیں گے۔

6. اب ہائبرنیٹ کو کنفیگر کرتے ہیں۔ ایسا کرنے کے لیے، hibernate.cfg.xml فائل بنائیں:

   <?xml version='1.0' encoding='utf-8'?>
   <!DOCTYPE hibernate-configuration PUBLIC
           "-//Hibernate/Hibernate Configuration DTD//EN"
           "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
   
   <hibernate-configuration>
       <session-factory>
           <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
           <property name="hibernate.connection.driver_class">org.h2.Driver</property>
   
           <property name="hibernate.connection.url">jdbc:h2:~/db/onetoone</property>
           <property name="hibernate.connection.username">root</property>
           <property name="hibernate.connection.password"/>
   
           <property name="hibernate.hbm2ddl.auto">update</property>
   
           <property name="hibernate.show_sql">true</property>
           <property name="hibernate.format_sql">true</property>
           <property name="hibernate.use_sql_comments">true</property>
   
           <property name="hibernate.generate_statistics">true</property>
   
           <property name="hibernate.jdbc.batch_size">50</property>
           <property name="hibernate.jdbc.fetch_size">50</property>
   
           <property name="hibernate.order_inserts">true</property>
           <property name="hibernate.order_updates">true</property>
           <property name="hibernate.jdbc.batch_versioned_data">true</property>
   
           <mapping class="com.qthegamep.forjavarushpublication2.entity.Book"/>
           <mapping class="com.qthegamep.forjavarushpublication2.entity.Author"/>
       </session-factory>
   </hibernate-configuration>

خصوصیات کی تفصیل :

1. hibernate.dialect DBMS کی بولی ہے جسے ہم نے منتخب کیا ہے۔
2. hibernate.connection.driver_class — ہمارے DB کی ڈرائیور کلاس۔
3. hibernate.connection.url - ہمارے DB کا utl۔ آپ اسے پہلے نقطہ سے لے سکتے ہیں جہاں ہم نے ڈی بی کو تشکیل دیا ہے۔
4. hibernate.connection.username - DB صارف کا نام۔
5. hibernate.connection.password — DB صارف کا پاس ورڈ۔
6. hibernate.hbm2ddl.auto - ٹیبل جنریشن ترتیب دینا۔ اگر اپ ڈیٹ ہوتا ہے، تو یہ پیدا نہیں ہوتا ہے اگر یہ پہلے ہی بنا ہوا ہے، لیکن صرف اسے اپ ڈیٹ کرتا ہے۔
7. hibernate.show_sql - چاہے DB سوالات دکھائے جائیں۔
8. hibernate.format_sql - چاہے DB سوالات کو فارمیٹ کیا جائے۔ اگر نہیں تو وہ سب ایک لائن پر ہوں گے۔ میں اسے آن کرنے کی تجویز کرتا ہوں۔
9. hibernate.use_sql_comments - تبصرے DB سوالات۔ اگر یہ Insert ہے تو درخواست کے اوپر ایک تبصرہ لکھا ہوا ہے کہ درخواست Insert قسم کی ہے۔
10. hibernate.generate_statistics - نوشتہ جات تیار کرتا ہے۔ میں زیادہ سے زیادہ لاگنگ کو ترتیب دینے کی سفارش اور سفارش کرتا ہوں۔ لاگز کو پڑھنے سے آپ کے ORM کے ساتھ صحیح طریقے سے کام کرنے کے امکانات بڑھ جائیں گے۔
11. hibernate.jdbc.batch_size — زیادہ سے زیادہ بیچ کا سائز۔
12. hibernate.jdbc.fetch_size — بازیافت کا زیادہ سے زیادہ سائز۔
13. hibernate.order_inserts - متحرک داخلوں کی اجازت دیتا ہے۔
14. hibernate.order_updates - متحرک اپ ڈیٹس کی اجازت دیتا ہے۔
15. hibernate.jdbc.batch_versioned_data - بیچنگ کی اجازت دیتا ہے۔ اپنے DBMS کو دیکھیں: ہر کوئی اس کی حمایت نہیں کرتا ہے۔
16. نقشہ سازی کی کلاس - وہ کلاسیں جو ہمارے ادارے ہیں۔ ہر چیز کو درج کرنے کی ضرورت ہے۔

7. اب ہمارے جوہر کا تعین کرنا ہوگا۔ ہم اسے استقامت والے ٹیب میں چیک کر سکتے ہیں:

   نتیجہ:

8. ہمیں تفویض ڈیٹا کو بھی ترتیب دینے کی ضرورت ہے:

   نتائج: ہم نے ون ٹو ون میپنگ کی ہے۔ مواد صرف معلوماتی مقاصد کے لیے ہے، تفصیلات حوالہ جات میں ہیں۔

ایک سے کئی رشتہ

یہاں برانچ سے لنک کریں ۔ میں مضمون میں مزید کوڈ پوسٹ نہیں کروں گا، کیونکہ یہ پہلے ہی بہت طویل ہے۔ ہم GitHub پر تمام کوڈ کو دیکھتے ہیں۔

1. ابتدائی اسکرپٹ پر عمل کرنے کے نتیجے میں ، ہمیں درج ذیل ملتا ہے:

   کیا آپ پچھلی میز سے فرق محسوس کرتے ہیں؟

2. خاکہ:

   ایک سے کئی رشتہ - ایک مصنف کی کئی کتابیں ہو سکتی ہیں۔ بائیں ہستی ایک یا زیادہ دائیں سے مساوی ہے۔

3. نقشہ سازی میں فرق تشریحات اور فیلڈز میں ہوگا:

   مصنف کی کلاس میں ایک فیلڈ ظاہر ہوتا ہے :

   @OneToMany(fetch = FetchType.LAZY, mappedBy = "author")
   private Set<Book> books;

   یہ پہلے سے ہی ایک سیٹ ہے، کیونکہ ہمارے پاس کئی کتابیں ہو سکتی ہیں۔ @OneToMany رویہ کی قسم کے بارے میں بات کر رہا ہے۔ FetchType.Lazy کا کہنا ہے کہ ہمیں کتابوں کی پوری فہرست لوڈ کرنے کی ضرورت نہیں ہے اگر درخواست میں اس کی وضاحت نہیں کی گئی ہے۔ یہ بھی کہا جانا چاہیے کہ اس فیلڈ کو toString میں شامل نہیں کیا جا سکتا، ورنہ ہم StackOverflowError سگریٹ نوشی شروع کر دیں گے۔ میرا پیارا لومبوک اس کا خیال رکھتا ہے:

   @ToString(exclude = "books")

   کتاب کی کلاس میں ہم کئی سے ایک فیڈ بیک کرتے ہیں:

   @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
   @JoinColumn(name = "AUTHOR_ID", nullable = false)
   private Author author;

   یہاں ہم یہ نتیجہ اخذ کرتے ہیں کہ ایک سے کئی کئی سے ایک کا عکس ہے اور اس کے برعکس۔ اس بات پر زور دیا جانا چاہئے کہ ہائبرنیٹ دو طرفہ مواصلات کے بارے میں کچھ نہیں جانتا ہے۔ اس کے لیے یہ دو مختلف کنکشن ہیں: ایک ایک سمت میں، دوسرا مخالف سمت میں۔

4. hibernate.cfg.xml میں کچھ زیادہ نہیں بدلا ہے ۔

5. استقامت:

متعدد سے ایک رشتہ

چونکہ کئی سے ایک ایک سے کئی کا عکس ہے، اس لیے کچھ اختلافات ہوں گے۔ یہاں برانچ سے لنک کریں ۔

1. ابتدائی اسکرپٹ پر عمل کرنے کے نتیجے میں ، ہمیں درج ذیل نتیجہ ملتا ہے:

2. خاکہ:

3. نقشہ سازی میں فرق تشریحات اور فیلڈز میں ہوگا:

   مصنف کی کلاس میں اب کوئی سیٹ نہیں ہے ، کیونکہ یہ کتاب کی کلاس میں چلا گیا ہے۔

4. hibernate.cfg.xml

5. استقامت:

کئی سے کئی رشتہ

آئیے سب سے دلچسپ رشتے کی طرف چلتے ہیں۔ یہ رشتہ شرافت اور بے حیائی کے تمام اصولوں کے مطابق ایک اضافی جدول کے ذریعے بنایا گیا ہے۔ لیکن یہ میز ایک ہستی نہیں ہے۔ دلچسپ، ٹھیک ہے؟ آئیے اس گندگی پر ایک نظر ڈالیں۔ یہاں برانچ سے لنک کریں ۔

1. ابتدائیہ اسکرپٹ کو دیکھیں ، یہاں ایک اضافی HAS ٹیبل ظاہر ہوتا ہے۔ ہمیں مصنف کی کتاب کی طرح کچھ ملتا ہے۔

   اسکرپٹ پر عمل کرنے کے نتیجے میں، ہمیں درج ذیل ٹیبل ملیں گے:

2. خاکہ:

   ہماری مثال میں، یہ پتہ چلتا ہے کہ ایک کتاب کے بہت سے مصنف ہو سکتے ہیں، اور ایک مصنف کی بہت سی کتابیں ہو سکتی ہیں۔ وہ اوورلیپ ہو سکتے ہیں۔

3. میپنگ کلاسز کے اندر کلاسز کے سیٹ ہوں گے۔ لیکن جیسا کہ میں نے کہا، HAS ٹیبل کوئی وجود نہیں ہے۔

   مصنف کی کلاس :

   @ManyToMany
   @JoinTable(name = "HAS",
           joinColumns = @JoinColumn(name = "AUTHOR_ID", referencedColumnName = "ID"),
           inverseJoinColumns = @JoinColumn(name = "BOOK_ID", referencedColumnName = "ID")
   )
   private Set<Book> books;

   @ManyToMany ایک قسم کا رشتہ ہے۔

   @JoinTable - یہ بالکل وہی ہے جو خصوصیت کو ایک اضافی HAS ٹیبل کے ساتھ مربوط کرے گا۔ اس میں ہم دو صفات بیان کرتے ہیں جو دو اداروں کی بنیادی کلیدوں کی طرف اشارہ کریں گے۔

   کتاب کی کلاس :

   @ManyToMany(fetch = FetchType.LAZY, mappedBy = "books")
   private Set<Author> authors;

   یہاں ہم FetchType اور اس فیلڈ کی نشاندہی کرتے ہیں جسے ہم نقشہ بنانے کے لیے استعمال کریں گے۔

4. ہمارا hibernate.cfg.xml پھر کوئی تبدیلی نہیں ہوئی (میں اس حقیقت کو ذہن میں نہیں رکھتا کہ ہم نے ہر برانچ کے لیے ایک نیا DB بنایا ہے)۔

5. استقامت:

ڈیبریفنگ

لہذا، ہم نے سطحی طور پر DB تعلقات کی اقسام کا جائزہ لیا ہے اور یہ معلوم کیا ہے کہ انہیں ORM ماڈل میں کیسے نافذ کیا جائے۔ ہم نے ایک ٹیسٹ پروجیکٹ لکھا جو تمام کنکشنز کو ظاہر کرتا ہے، اور یہ معلوم کیا کہ ہائبرنیٹ/jpa کو کیسے ترتیب دیا جائے۔ افف

مفید لنکس

• اصل میں منصوبہ خود
• ون ٹو ون برانچ
• ایک سے کئی شاخیں۔
• کئی سے ایک شاخ
• کئی سے کئی شاخیں۔
• اسے پڑھ
• اور اسے پڑھیں

میرے پچھلے مضامین:

• مسلسل انضمام
• کوڈ کوریج
• نشان لگانا

PS متن میں غلطیاں اور کوتاہیاں ہو سکتی ہیں۔ پی پی ایس یہ مضمون لکھتے وقت مصنف کچھ عجیب سگریٹ نوشی کر رہا تھا۔ آپکی توجہ کا شکریہ!