Friday, April 29, 2016

XML DTD

DTD ဆိုတာ Document Tags Definition ကိုအတိုကောက်ခေါ်ဆိုခြင်းဖြစ်ပါတယ်။ XML document ထဲမှာ ဘယ် elements တွေပါရမယ်ဆိုတာကို သတ်မှတ်ပေးတာဘဲဖြစ်ပါတယ်။ တနည်းပြောရရင် XML Document တစ်ခုကို rule သတ်မှတ်ပေးတာဘဲဖြစ်ပါတယ်။ (XML document တစ်ခု valid ဖြစ်၊မဖြစ် DTD ကိုအသုံးချပြီးတော့ ဆုံးဖြတ်နိုင်ပါတယ်။)
DTD Example

[ ] tag ထဲမှာ အသုံးပြုမယ့် elements တွေမှန်သမျှကို ကြေညာထားပေး ရပါတယ်။ ကြေညာထားတဲ့ Element Tag တွေကို attributes တွေသတ်မှတ်ပေးတာ၊ content values တွေကို သတ်မှတ်ပေးတာ စသည်တို့ကို special character တွေကိုအသုံးပြုပြီးတော့ ကြေညာပေးနိုင်ပါတယ်။ (Limitation ပေးနိုင်ပါတယ်)      အရင်ဆုံး တွေ့ရတဲ့ Person ဆိုတာကတော့ Root element ဘဲဖြစ်ပါတယ်။ Person tag ထဲမှာ ထည့်လို့ရတာကတော့ Name tag တစ်ခုတည်းဘဲဖြစ်ပါတယ်။ <Name></Name> ။ Name tag မဟုတ်သောအခြားသော tag တွေကိုထည့်သွင်းလို့ရမှာမဟုတ်ပါဘူး။ ဘာလို့လည်းဆိုရင် DTD ထဲမှာ ကြေညာထားတာက Person tag ထဲမှာ Name tag ထဲရှိရမယ်ဆိုတာကြောင့်ပါ။ (Rule သတ်မှတ်ပေးထားတာပေါ့)  Name နောက်မှာပါတဲ့ + sign က တော့ အနည်းဆုံး တစ်ကြိမ်ပါရမယ် ကိုဆိုလိုပါတယ်(One or More) ။ Person tag ထဲမှာ ဘာ tag  မှမပါဘဲ တော့ မဖြစ်ရဘူး ၊ Name tag တစ်ခုတော့ အနည်းဆုံးပါနေရပါမယ်။

 Valid XML Document
Invalid XML Document
Name (CDATA) ဆိုတာက တော့ Name tag ထဲမှာပါဝင်ရမယ့် data type အမျိုးအစားကို သတ်မှတ်   ပေးခြင်းဖြစ်ပါတယ်။ Data Type နှစ်မျိုးရှိပါတယ်။ တစ်ခုက CDATA နှင့် ကျန်တစ်ခုကတော့ PCDATA တို့ဘဲဖြစ်ပါတယ်။ CDATA ကတော့ ကြိုက်တဲ့ character data ဖြစ်လို့ရတယ်။ ဒါပေမဲ့ nested element tag တွေကိုတော့ လက်မခံဘူးပေါ့။ ဥပမာမှာဆိုရင် Name tag ထဲမှာအခြားသော element tag ထပ်ထည့်လိုရမှာမဟုတ်ပါဘူး။

CDATA Example
DTD မှာ attribute value ကိုသတ်မှတ်ပေးခြင်ရင်တော့
            
<! ATTLIST Element_name  Attribute_name  attribute_type  default_value >

ပုံစံကြေညာပေးရပါတယ်။ ဥပမာမှာ Gender ကို Attribute တစ်ခုအနေနှင့်ထည့်ပြပါမည်။

 XML Document with Attribute

 Name tag မှာ Gender attribute ကိုထည့်သွင်းခြင်းဖြစ်ပါတယ်။ ( ) ထဲမှာကတော့ attribute value တွေကိုကြေညာပေးထားပါတယ်။ Gender Attribute က Male value ဒါမှမဟုတ်၊ Female value ဘဲရှိမယ် ဆိုတာကို သတ်မှတ်ပေးထားတာပါ။ "" ထဲမှာကတော့ default value ဘဲဖြစ်ပါတယ်။

XML Document with Internal DTD

XML Document with External DTD

   DTD ကို *.dtd  ပုံစံဖြင့် save ပြီး XML Document ကနေ Link ချိတ်အသုံးပြုနိုင်ပါတယ်။

အခုဆိုရင် DTD ကို အနည်းအငယ် သိရှိသွားမည်ဖြစ်ပါတယ်။ DTD ကိုသုံးတဲ့အခါမှာ အားသာချက်၊ အားနည်းချက်တွေရှိပါတယ်။ အားသာချက်ကတော့ XML Document ကို valid စစ်ပေးနိုင်ခြင်း၊ အားနည်းချက်ကတော့ XML Parser ကို second syntax ဖြစ်ပေါ်စေခြင်းတို့ဘဲဖြစ်ပါတယ်။ ပြီးတော့ namespace   ကိုလည်း support မပေးပါဘူး။
By

Wednesday, April 20, 2016

DOM vs SAX

DOM နှင့် SAX နှစ်ခုစလုံးမှာ သူဟာနှင့်သူ အားသာချက်၊ အားနည်းချက်တွေရှိပါတယ်။

DOM က document structure တစ်ခုလုံးကို memory ပေါ်တင်တဲ့အတွက်ကြောင့် document structure ကြီ:ရင် ကြီးသလောက် memory resource တွေလိုအပ်ပါတယ်။ ဒါပေမဲ့ သူက element တွေ တစ်ခုနှင့်တစ်ခုကြားမှာ အလွယ်တကူသွားလာနိုင်ခြင်း၊ element content တွေကို modify (read/write) လုပ်ရတာလွယ်ကူခြင်းတို့ကြောင့် အသုံးများပါတယ်။ (ဥပမာ - application တစ်ခုရဲ့ system configure file)

SAX ကတော့ document structure တစ်ခုလုံးကို memory ပေါ်မတင်တဲ့အတွက် less-memory intensive ဘဲလိုအပ်ပါတယ်။ SAX ကိုများသောအားဖြင့် element content များတဲ့ XML document တွေကို parse လုပ်တဲ့နေရာမှာအသုံးပြုပါတယ်။ SAX parser တွေက XML document ကို modify (Read only) လုပ်မပေးနိုင်ပါဘူး။ (ဥပမာ directory data file )
DOM
SAX
Read Mode
Reads entire Document
Reads Node by Node
XML File size
Small/Medium XML File
Large XML File
Parser Type
Tree based Parser
Event based Parser
Speed
Little Slow
Faster
Read
Yes
Yes
Write
Yes
No

DOM Parser Java Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package XML;

import javax.xml.parsers.*;
import java.io.*;
import org.w3c.dom.*;
import org.xml.sax.*;

public class DOMparser {
 
 
 
 public static void main(String [] args){
  try{
   //Read File
   File xmlFile=new File("catalog.xml");
   
   //DocumentBuilderFactory
   DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
   
   //DocumentBuilder
   DocumentBuilder builder=factory.newDocumentBuilder();
   
   //Document
   Document document=builder.parse(xmlFile);
   
   //Get Root Element
   Element rootElement=document.getDocumentElement();
   
   System.out.println("Root Elemnet :" + rootElement.getTagName());
   
   parseNode(null,rootElement);
   
   
  }catch(Exception e){
   e.printStackTrace();
  }
  
 }
 
 public static void parseNode(Element previousNode,Element visitNode){
  
  if(previousNode != null){
   System.out.println("Element "+ previousNode.getTagName() + " has element :");
  }
  System.out.println("Element Name :" + visitNode.getTagName());
  
  //List Attributes From VisitNode
  if(visitNode.hasAttributes()){
   System.out.println("-Elment " + visitNode.getTagName() +" has Attributes :");
   NamedNodeMap attributes=visitNode.getAttributes();
   
   //Extract Attributes
   for(int i=0; i<attributes.getLength(); i++){
    Attr attribute=(Attr)(attributes.item(i));
    //Print Attribute
    System.out.println("--Attribute :" + attribute.getName() + " = " + attribute.getValue());
   }
  }//End of Attributes List
   
  //Read Nested Element or Child Node
  //Get Child Node List
  NodeList nodeList=visitNode.getChildNodes();
  
  for(int i=0; i<nodeList.getLength(); i++){
   //Get Child Node
   Node node=nodeList.item(i);
   
   if(node.getNodeType()==Node.ELEMENT_NODE){
    Element element=(Element)node;
    
    //Do same Thing /Revcursive Algorithm
    parseNode(visitNode,element);
   }
   else if(node.getNodeType()==Node.TEXT_NODE){
    String str=node.getNodeValue().trim();
    if(str.length()>0){
     System.out.println("---Element Text: " + str);

    }
   }
   
  }
  
  
  
 }


}



SAX Parser Java Example Code


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package XML;

import org.xml.sax.*;
import javax.xml.parsers.*;
import org.xml.sax.helpers.*;
import java.io.*;

public class SAXParser {
 
 public static void main(String []args){
  SAXParser saxParser=new SAXParser();
  saxParser.parseDocument();
 }
 
 public void parseDocument(){
  try{
   //SAX Parser Factory
   SAXParserFactory factory=SAXParserFactory.newInstance();
   
   //SAX Parser
   SAXParser parser=factory.newSAXParser();
   
   //Handler **
   DefaultHandler handler=new CustomSAXHandler();
   //Set File to Parse and Set Handler
   parser.parse(new File("catalog.xml"), handler);
   
   
  }catch(Exception e){
   e.printStackTrace();
  }
 }
 
 private class CustomSAXHandler extends DefaultHandler {
  //Constructor
  public CustomSAXHandler(){
   
  }
  
  //Start Document
  public void startDocument() throws SAXException {
   System.out.println("Event Type : Start Document ");
  }
  
  //End Document
  public void endDocument() throws SAXException {
     System.out.println("Event Type : End Document ");
  }
    
  //Start Element
  public void startElement (String uri,String localName,String qName,Attributes attributes){
   System.out.println("Event Type: Start Element");
   System.out.println("Element Name:" + qName);
   for (int i = 0; i < attributes.getLength(); i++) {
   System.out.println("Attribute Name:" + attributes.getQName(i));
   System.out.println("Attribute Value:" + attributes.getValue(i));
   }
  }
  
  //End Element
  public void endElement(String uri, String localName, String qName)
    throws SAXException {
    System.out.println("Event Type: End Element");
  }
  
  //Get Text
  public void characters(char[] ch, int start, int length)
    throws SAXException {
    System.out.println("Event Type: Text");
    String str = (new String(ch, start, length));
    System.out.println(str);
  }
  
  //Error
  public void error(SAXParseException e)
    throws SAXException{
    System.out.println("Error "+e.getMessage());
  }
  public void fatalError(SAXParseException e)
    throws SAXException{
    System.out.println("Fatal Error "+e.getMessage());
  }
  public void warning(SAXParseException e)
    throws SAXException{
    System.out.println("Warning "+e.getMessage());
  }


 }

}

By

Sunday, April 17, 2016

XML

XML ဆိုတာက Extensible Markup Language ကိုခေါ်ဆိုခြင်းဖြစ်ပြီး platform independent တဲ့ text-based markup language တစ်ခုဖြစ်ပါတယ်။ XML ကို Meta-data Language လို့လည်းခေါ်ပါသေးတယ်။ XML ကိုမပြာခင်မှာ HTML ကိုအရင်သိထားသင့်ပါတယ်။ HTML မှာ သတ်မှတ်ထားသော tag တွေသာအသုံးပြုလို့ရပါတယ်။ သူ့ထဲမှာမပါတဲ့ tag တွေကိုရေးလို့မရပါဘူး။ (အသစ်ထပ်ထည့်လို့မရဘူးပေါ့) အဲ့တာမျိုးကို not extensible လို့ပြောပါတယ်။ XML မှာတော့ ကြိုက်တဲ့ tag ကိုရေးသားနိုင်ပါတယ်။ ကိုယ့်စိတ်ကြိုက်သတ်မှတ်ပေးလို့ရပါတယ်။ (စိတ်ကြိုက်ရေးလို့ရတယ်ဆိုတာ ဖြစ်သလိုရေးရတာမဟုတ်ပါဘူး၊ XML မှာအခြေခံသတ်မှတ်ထားတဲ့ စည်းကမ်းချက်တွေကိုတော့လိုက်နာရပါတယ်။) XML document  တွေကိုများသောအားဖြင့် low level data တွေဖြစ်တဲ့ System configuration file တွေအတွက်နှင့် document တစ်ခုရဲ့ meta data ကိုသိမ်းဆည်းရန်အတွက်အသုံးပြုပါတယ်။

XML Document

XML Document တစ်ခုမှာ အောက်ပါ components တွေပါဝင်ပါတယ်။
  1. Prologue
  2. Elements
  3. Attributes

Prologue ဆိုတာက XML Document မှာ version, encoding စတာတွေကို ကြေညာပေးတဲ့ အပိုင်းဘဲဖြစ်ပါတယ်။
            <? xml version=”1.0” encoding=”UTF-8”?>
အကယ်၍ prologue သာမပါဘူးဆိုရင် XML doc က default အနေနဲ့ version=”1.0”နှင့် encoding=”UTF-8”ကိုတည်ဆောက်ပေးမှာဖြစ်ပါတယ်။အခြားသော tag တွေနှင့်မတူတာက Prologue tag မှာ <? နှင့်စပြီး ?> နှင့်အဆုံးသတ်ပါတယ်။

Elements

Prologue ပြီးတဲ့အခါကျန်သော tag တွေအားလုံးကို element လို့ခေါ်ပါတယ်။ XML document ထဲက element tag ကိုအောက်ပါအတိုင်းရေးသားပါတယ်။
            <tag_name attribute_name=”attribute_value” >                               content                      </tag_name>
Element ထဲမှာ content လည်းဖြစ်နိုင်သလို နောက်ထပ် element tag (nested element) တစ်ခုလည်းဖြစ်နိုင်ပါတယ်။ Attribute: Element tag တစ်ခုစိတိုင်းမှာ ပါဝင်နိုင်ပါတယ်။ XML document tag တွေက case-sensitive ဖြစ်ပါတယ်။

Example of XML document
Sample XML Document

            Example မှာဆိုရင် Programming tag က အပြင်ဘက်ဆုံး tag ဖြစ်ပြီး သူ့ကို root node (Document Element) လို့ခေါ်ပါတယ်။ Programming tag ထဲမှာ အခြား tag 4 ခုပါဝင်ပါတယ်။ (Java, C, VB, HTML) Java tag ထဲမှာ attribute တစ်ခုပါဝင်ပါတယ်။ use  ဆိုတာ attribute name ဖြစ်ပြီး ၊ JDK8 ဆိုတာကတော့ attribute value ဘဲဖြစ်ပါတယ်။ Hello World ဆိုတာက content value ဘဲဖြစ်ပါတယ်။ Web tag ထဲမှာတော့ Html ရယ် Database ရယ် ဆိုပြီးတော့ nested tag ၂ခု ထည့်သွင်းထားပါတယ်။
XML document တစ်ခုဟာ only data storage ပါဘဲ။ သူကိုယ်တိုင် သူ့ထဲမှာ ပါဝင်တဲ့ data(content) တွေကိုမပြသနိုင်ပါဘူး။အဲ့တော့ သူ့ထဲက data တွေကို သိရှိနိုင်ဖို့အတွက် သူ့ကို Parse လုပ်ရပါတယ်။ အဲ့လို လုပ်ဆောင်ပေးသော function ကို XML Parser လို့ခေါ်ပါတယ်။

XML Parser

            XML Document အတွင်းမှာရှိတဲ့ element content တွေကို access လုပ်နိုင်ရန်အတွက် XML parser ကထောက်ပံ့ပေးပါတယ်။ (XML Document တစ်ခုကို parse မလုပ်ခင် အရင်ဆုံး parse လုပ်မဲ့ document က error ကင်းနေဖို့လိုအပ်ပါတယ်။ အဲ့လိုမျိုး XML document တစ်ခု error ကင်းကြောင်းစမ်းသတ်တဲ့နည်းတွေအများအပြားရှိပါတယ်) Document တစ်ခုကို parse လုပ်တဲ့အခါ နည်းလမ်း ၂ မျို:အသုံးပြုလို့ရပါတယ်။
·         Document Object Model (DOM)
·         Simple API for XML (SAX)

DOM Parser
            DOM parser က document တစ်ခုလုံးကို ဖတ်လိုက်ပါတယ်။ ဆိုလိုတာက document  တစ်ခုလုံးကို memory ပေါ်တင်ပေးလိုက်တာပါဘဲ။ tree-structure ပုံစံအနေနှင့်ပေါ့ ။ ( Document အတွင်းမှာရှိတဲ့ element တစ်ခုချင်းစိက tree node အနေနှင့် ရောက်ရှိသွားပါတယ်။ )
DOM parser's memory structure

 
SAX Parser

            SAX Parser က Event-Driven parser တစ်ခုဖြစ်ပါတယ်။ သူက document ကိုအပိုင်းတွေခွဲလုပ်တာပါ။ (Document structure တစ်ခုလုံးကို memory ပေါ်မတင်ပါဘူး Line by Line လုပ်ဆောင်သွားတာဘဲဖြစ်ပါတယ်)
Event Sequence SAX Processing

By

Friday, April 8, 2016

Database Language

Database ကိုအသံုးျပဳဖို့အတြက္ database Language ဆိုတာလိုအပ္ပါတယ္။ database language ေတြက Database schema ေတြ၊ actual data ေတြကို define သတ္မွတ္ေပးရန္အတြက္အသံုးျပဳၾကပါတယ္။ Database Language အမ်ိဳးအစား ႏွစ္မ်ိဳးရွိပါတယ္။
  • SQL (Structured Query Language)
  • NDL

Relational data model ေတြကို အသံုးခ်ဖို့အတြက္ (data manipulation လုပ္ဖိုအတြက္) SQL ကိုအသံုးျပဳပါတယ္။ NDL ကေတာ့ network data model ကို manipulation လုပ္ဖို့အတြက္အသံုးျပဳၾကပါတယ္။
Database Language ေတြကို အေသးစိတ္ေလ့လာမယ္ဆိုရင္ သူ့ကို အမ်ိဳးအစား ၃ မ်ိဳးခြဲျခားႏုိင္ပါတယ္။
  • Data Definition Language (DDL)
  •  Data Manipulation Language (DML)
  •  End User Language (EUL)

Data Definition Language ဆိုတဲ့အတိုင္းဘဲ သူက data ေတြကို define လုပ္ေပးႏိုင္ပါတယ္။ တနည္းေျပာရရင္ schema ေတြကို သတ္မွတ္ေပးႏိုင္ပါတယ္။ ဥပမာ Create ၊ Drop ၊ Rename တို့ကုိေျပာျခင္းျဖစ္ပါတယ္။
Data Manipulation Language ဆိုတာကေတာ့ database ကို operation လုပ္ဖိုအတြက္ အသံုးျပဳတာျဖစ္ပါတယ္။ ဥပမာ table တစ္ခုကေန လုိခ်င္တဲ့ row ကို ဆဲြထုတ္တာမ်ိဳးကို ဆိုလိုပါတယ္။ (Select ၊ Insert ၊ Update စသည္ျဖင့္)
End User Language ဆိုတာကေတာ့ end user တွေအတွက် query Language ဘဲဖြစ်ပါတယ်။

SQL Database Language

            ခုအသံုးမ်ားဆံုး data model ကုိေျပာပါဆိုရင္ relational data model ဘဲျဖစ္ပါတယ္။ SQL ကေတာ့ relational data model ေတြကို manipulate လုပ္ဖိုအတြက္ အသံုးျပဳတဲ့ database Language တစ္ခုပါဘဲ။ SQL က non-procedural Language ျဖစ္တဲ့အတြက္ သူ့ရဲ့ statement ေတြက ရိုးရွင္း ပါတယ္။ တစ္နည္းေျပာရရင္ English Words စကားအတိုင္း ေရးသားထားျခင္း ဘဲျဖစ္ပါတယ္။ အဲ့တာေၾကာင့္ဘဲ SQL ကို ေနာ္တစ္မ်ိဳးေခါတာက SEQUEL ( Structured English Query Language ) ဘဲျဖစ္ပါတယ္။
(manipulate လုပ္တယ္ဆိုတာ set Operations ေတြျဖစ္တဲ့ Union ၊ Difference ၊ Intersection ၊ Cartesian product လို operations မ်ိဳးကိုလည္ေကာင္း ၊ Relation Operations ေတြျဖစ္တဲ့ Projection ၊ Join ၊ Divide လို operation မ်ိဳးကိုလည္းေကာင္း ျပဳလုပ္ေပး ျခင္းျဖစ္ပါတယ္။)
SQL structure
SQL မှာ Embedded SQL နှင့် Interactive SQL ဆိုပြီးနှစ်မျိုးသုံးလို့ရပါတယ်။

Embedded SQL ကို host language system မှာအသုံးပြုပါတယ်။ Host Language system ဆိုတာက database တွေကိုအခြား programming languages တွေကနေလှမ်းပြီးတော့ manipulate လုပ်တဲ့ system မျိုးဖြစ်ပါတယ်။ ဥပမာ ပြောရရင် Java program code ထဲကနေပြီးတော့ database queries တွေကို ခေါ်သုံးတာမျိုးဖြစ်ပါတယ်။

Interactive SQL ဆိုတာကတော့ self-contained system မှာအသုံးပြုတာဖြစ်ပါတယ်။ သူတို့က အခြား programming language တွေကနေပြီးတော့ database ကို manipulate လုပ်တာမဟုတ်ဘဲ၊ database manipulation language (MySQL) တစ်ခုတည်းကဘဲ manipulate လုပ်တာဖြစ်တယ်။


Data Loading

            Database တွေတည်ဆောက်ပြီးသွားတဲ့အခါမှာ database (table) ထဲကို data တွေ ကိုထည့်သွင်းပေးရပါတယ်။အဲ့လို process မျိုးကို database loading လို့ခေါ်ပါတယ်။ database loading ကို သုံးနည်းဖြင့်ပြုလုပ်နိုင်ပါတယ်။
            Interactive System ဆိုတာကတော့ SQL statement တစ်ခုဖြစ်တဲ့ INSERT ကိုအသုံးပြုပြီးတော့ data တွေကို line by line ထည့်သွင်းတာဘဲဖြစ်ပါတယ်။ Line by line လုပ်တာကြောင့် များစွာသော data တွေကို ထည့်ရာမှာ အစဉ်မပြေပါဘူး။
            Host Language System ဆိုတာကတော့ programming language တစ်ခုခုကိုအသုံးချပြီး data တွေကို ထည့်တာဘဲဖြစ်ပါတယ်။ Programming ကိုအသုံးပြုပြီးထည့်တာကြောင့် condition ( data ကို filter) ပြုလုပ်နိုင်ပါတယ်။

            Utility Program System  ဆိုတာကတော့ utility program တွေကိုအသုံးပြုပြီးတော့ data တွေကိုထည့်သွင်းတာဘဲဖြစ်ပါတယ်။ များစွာသော data တွေကိုထည့်သွင်းရာမှာအသုံးဝင်ပါတယ်။
By

Wednesday, April 6, 2016

Understanding JVM

JVM လို့ေျပာတာနဲ Java developers ေတာ္ေတာ္မ်ားမ်ား ရင္းႏွီးျပီးသားျဖစ္မွာပါ။ Java app ကို run ေတာ့မယ္ဆိုရင္ အရင္ဆံုး class file ေျပာင္း၊ ျပီးရင္ bytecode ထုတ္တာျပီး  JRE ထဲမွာ execute  လုပ္လိုက္တာဘဲျဖစ္ပါတယ္။ JRE ထဲမွာဘာေတြပါဘညး္၊ ဘယ္လိုအလုပ္လုပ္ လည္းဆိုတာ သိထားဖို့လိုပါတယ္။

JRE ဆိုတာ Java API ေတြရယ္ JVM ရယ္ေပါင္းစပ္ထားတဲ့ package တစ္ခုပါဘဲ။ JRE ရဲံအဓိက component ကေတာ့ JVM (Java Virtual Machine) ဘဲျဖစ္ပါတယ္။
Virtual Machine ေတြရဲ့သေဘာ သဘာ၀အရ သူတို့က software implementation ေတြျဖစ္ျပီးေတာ့၊ program ေတြကို တကယ့္ physical machine ေပါမွာတင္ run ေနရသလိုမ်ိဳးလုပ္ေဆာင္ေပးပါတယ္။ Java က platform independence ဘာေၾကာင့္ျဖစ္တာလည္းဆိုရင္ JVM ေၾကာင့္ျဖစ္တာပါ။ Java ကိုစတင္ create လုပ္ကတည္းက WORA (Write once, Run Anywhere) ျဖစ္ဖို့အတြက္ရည္ရြယ္တာေၾကာင့္ တကယ္ physical machine (OS platforms ကုိဆိုလိုပါတယ္) ေပါမွာမွီခုီမူမရိွေအာင္ ျပဳလုပ္ထားပါတယ္။ သူ့အတြက္ ကိုယ္ပိုင္ machine (JVM) ေလးတစ္ခုတည္ေဆာက္လိုက္ျပီး bytecodes ေတြကို execute လုပ္ေပးႏိုင္တာဘဲျဖစ္ပါတယ္။
Java ကို company တစ္ခုတည္းကေန တည္ထြင္ခဲ့ေပမဲ့ JVM ကို မတူညီတဲ့ organization  ေတြကေနျပီးေတာ့ တည္ထြင္ထားပါတယ္။ အဲ့ေတာ့ JVM type ေတြက အမ်ိဳးမ်ိဳးရွိပါတယ္။ Oracle က ထုတ္တဲ့ JVM ၊ IBM ကထုတ္တဲ့ JVM စသည္ျဖင့္ေပါ့။ Google ကထုတ္တဲ့ Dalvik VM ဆိုတာလည္း JVM အမ်ိဳးအစားတစ္ခုပါဘဲ။
Complie 

Java app တစ္ခုကို complie လုပ္ လိုက္တဲ့အခါမွာ class file ထြတ္လာပါတယ္။


ထြက္လာတဲ့ class file ကို class loader ကေနျပီးေတာ့ လိုအပ္တဲ့ lib files ေတြႏွင့္ခ်ိတ္ဆက္ေပးပါတယ္။ ျပီးရင္ bytecode ကို ေျပာင္းလဲေပးလိုက္ပါတယ္။ bytecode ဆိုတာက user language ႏွင့္ machine language ၾကားမွာရွိတဲ့ middle-language တစ္ခုလဲျဖစ္ပါတယ္။ JVM က ၀င္လာတဲ့ bytecode ကို emulate လုပ္ေပးပါတယ္။ တစ္နည္းေျပာရရင္ bytecode ဆိုတာ JVM နားလည္တဲ့ language ျဖစ္သြားပါျပီး။
Class Loader ထဲမွာ process သံုးခုျပဳလုပ္ေပးပါတယ္။ Load ၊ Link ၊ Initialize ဆိုတာပါဘဲ ။ Load အပိုင္းမွာေတာ့  User-Defined Class Loader / System Class Loader / Extension Class Loader / Bootstrap Class Loader တုိပါ၀င္ပါတယ္။

Class Loader က class တစ္ခုကို load လုပ္ေတာ့မယ္ဆိုရင္ အထက္ပါ အတိုင္း စစ္ေဆးျပိးလုပ္ေဆာင္ပါတယ္။ User-Defined Class Loader က user မွ direct ေရးသားထားတဲ့ code ေတြကို load ေခါေပးပါတယ္။ System Class loader ကေတာ့ CLASSPATH ထဲမွာရွိတဲ့ class ေတြကို load ေခါေပးပါတယ္။ Extension Class Loader ကေတာ့ လုိအပ္တဲ့ Java API ေတြကို load လုပ္ေပးပါတယ္။ ေနာက္ဆံုး bootstrap class loader မွာေတာ့ JVM က စတင္ run ေနပါျပီး။
အဲ့တာ class တစ္ခုစာ process တစ္ခုပါ။ အျခားေသာ class ေတြရွိေသးတဲ့အတြက္ link process ကို ဆက္လက္လုပ္ေဆာင္ပါတယ္။

Link process ျပီးလို့ initializing လုပ္ျပီးသြားရင္ class loader အပိုင္းက ျပီးဆံုးသြားပါျပီး။ Class Loader ကေနထြက္လာတဲ့ output က Runtime Data Area ထဲကို ေရာက္ရွိသြားပါတယ္။

Runtime Data Area

            Runtime Data Area ဆိုတာ JVM ကို OS ေပါမွာ  run ႏိုင္ရန္အတြက္ သတ္မွတ္ေပးထားေသာ memory area ေလးတစ္ခုဘဲျဖစ္ပါတယ္။ Runtime Data Area ကို အပိုင္း ၅ ပိုင္းခဲြလုိရပါတယ္။ အတိအက်ေျပာရင္ ၆ ပိုင္းခြဲလို့ရတာပါ။

PC Register တစ္ခုက thread တစ္ခုအတြက္ဘဲ create လုပ္ပါတယ္။ ေနာက္ထပ္ thread တစ္ခုသာဆိုရင္ ေနာက္ထပ္ PC Register တစ္ခုထပ္ျပီး create လုပ္ေပးရပါတယ္။ ထိုနည္းတူစြာ JVM stack ႏွင့္ Native Method Stack တို့ကလညး္ အတူတူပင္ျဖစ္ပါတယ္။
Heap ႏွင့္ Method Area အပါအ၀င္ Runtime Constant Pool တုိ့က တစ္ခါ create လုပ္ယံုပါဘဲ ။ thread ေတြဘယ္ေလာက္ရွိရွိ သူတို့ကို တစ္ၾကိမ္တည္းသာ create လုပ္ေပးရပါတယ္။
PC register ဆုိ Program counter register ျဖစ္ျပီး executed လုပ္ထားတဲ့ JVM ရဲ့ instruction ေတြရွိတဲ့ address ဘဲျဖစ္ပါတယ္။ next instruction ေတြကို ရည္ညြန္းတာဘဲျဖစ္ပါတယ္။
Thread တစ္ခုအတြက္ JVM stack တစ္ခု ျဖစ္တယ္။ အဲ့ေတာ့ stack ေတြအားလံုးကို stack Frame ေပါမွာတင္ထားပါတယ္။ JVM က လိုအပ္သလို stack ေတြကို stack frame ေပါ push/pull လုပ္ေဆာင္ပါတယ္။
Native method stack ဆိုတာကေတာ့ Java မဟုတ္တဲ့ native code ေတြထားရွိရန္အတြက္သံုးတဲ့ stack တစ္ခုဘဲျဖစ္ပါတယ္။ တစ္နည္းေျပာရရင္ native interface ကေနတစ္ဆင့္ link ခ်ိတ္ထားတဲ့ c code ေတြကိုထားရန္အတြက္ ျဖစ္ပါတယ္။ c stack ေပ့ါ။ (program ေပါမူတည္ျပီး stack name ေျပာင္းနီင္သည္)
Method Area ဆိုတာ လြယ္လြယ္ေျပာရရင္ class data (static variables, field and method information, method bytecode constant pool) ေတြ store လုပ္တဲ့ space တစ္ခုျဖစ္ပါတယ္။
Heap ဆိုတာက objects ေတြ ၊ instances ေတြကို store လုပ္တဲ့ space တစ္ခုျဖစ္တယ္။ အဓိကကေတာ့ garbage
Collection အတြက္သံုးျပဳပါတယ္။ JVM အမ်ိဳးအစားေတြက heap ကိုကိုင္တယ္ ပံုခ်င္း မတူ ႏွင့္ garbage collect လုပ္၊မလုပ္ ေပါမွာကြဲျပားသြားပါတယ္။ 
By

Monday, April 4, 2016

3-Tier Schema and ERD

3-Tier Schema

            Data modeling ေတြလုပ္ေဆာင္ရန္အတြက္ ANSI-SPARC ကေနျပီးေတာ့ 3-tier schema ကို မိတ္ဆတ္ခဲ့ပါတယ္။ 3-Tier လို့ေျပာတဲ့အတိုင္းဘဲ သူ့မွာ အပိုင္းသံုးပိုင္းပါ ပါတယ္။

  1. External schema
  2. Internal schema
  3. Conceptual schema 
External schema က user point view က data ေတြ (user လိုခ်င္တဲ့ ပံုစံ) ကို အသံုးျပဳျပီး database ပံုစံတည္ေဆာက္တဲ့အပိုင္းျဖစ္ပါတယ္။ Conceptual schema ကေတာ့ data structure ကို logical အရ define လုပ္ေပးယံုပါ ။တကယ္ တည္ေဆာက္တာက internal schema အပိုင္းမွာျဖစ္ပါတယ္။ တစ္နည္းေျပာရရင္ internal schema က physical data structure ကို define လုပ္ေပးတာပါျဖစ္ပါတယ္။

ERD

          အေဆာက္ဦး တစ္ခုတည္ေဆာက္ေတာ့မယ္ ဆိုရင္ ဒီအတိုင္း ရမ္းသန္းေဆာက္လို့မရပါဘူး။ လိုအပ္တဲ့ design ေတြ ၊ resources ေတြကို analysis လုပ္ေပးျပီးမွ တည္ေဆာက္ရပါတယ္။ အေဆာက္ဦး ပံုစံ design ခ်တာမ်ိဳး -blueprint လုပ္တာမ်ိဳးလုပ္ရပါတယ္။ Database မွာလည္း ထိုနည္းတူစြာ ျပဳလုပ္ေပးရပါတယ္။ အဲ့လိုမ်ိဳး process ကို Entity-Relationship model (ERD) ဆိုတဲ့ diagram expressing ကေနျပီးေတာ့ ျပဳလုပ္ေပးပါတယ္။ ERD ပံုေတြဆိုတာ database blueprint ေတြျဖစ္ပါတယ္။ ERD က 3-Tier schema မွာဆိုရင္ conceptual schema အပိုင္းကို ေဖာ္ျပေပး တဲ့ diagram ေတြဘဲျဖစ္ပါတယ္။ ERD အဆင့္ထိ ဆိုရင္ DBMS independence ဘဲျဖစ္ပါေသးတယ္။  ဆိုလိုတာက အေဆာက္ဦးေဆာက္ဖို့ အတြက္ design ဆြဲတာ က ပံုစံခ်တာ သတ္သတ္ဘဲရွိပါေသးတယ္။ အဲ့ designed ဆြဲျပီးသား အေဆာက္ဦးကိုူ ဘာႏွင့္တည္ေဆာက္မွာလည္း (ဥပမာ သစ္သာ၊အုတ္ စသည္ျဖင့္) ဆိုတာက အပိုင္းတစ္ပိုင္းျဖစ္တယ္။ ERD က ပံုစံ သတ္သတ္ျဖစ္ျပီးေတာ့ အဲ့ကေနထြက္လာတဲ့ ပံုစံေပါမူတည္းျပီး ဘာ DBMS (ဥပမာ MySQL,Oracle စသည္ျဖင့္) ကိုသံုးမွာလညး္ ဆိုတာကို ျပဳလုပ္ၾကပါတယ္။
ERD model တစ္ခုမွာဆိုရင္ အပိုင္း ၃ ပိုင္းပါ ပါတယ္။

  1.   Entities
  2.  Relationships
  3.  Attributes
Entities ဆိုတာ က objects ေတြပါ။ သူ့ကို rectangle box ႏွင့္ေဖာ္ျပပါတယ္။ Relationship ဆိုတာကေတာ့ entity တစ္ခု ႏွင့္ entity တစ္ခုၾကားက ဆက္သြယ္မွဳပါဘဲ၊ သူ့ကုိ diamond ပံုစံျဖင့္ေဖာ္ျပပါတယ္။ Attribute ဆိုတာကေတာ့ entity ထဲမွာပါ ၀င္တဲ့ values ေတြပါ (characteristics of entities) ၊ သူ့ကုိ oval ပံုုစံျဖင့္ေဖာ္ျပပါတယ္။

ပံုတြင္ ေဖာ္ျပသည့္အတိုင္း Driver က ေနျပီး ကား ေမာင္းျပီး ခရီးတစ္ခု သြားတာ ျဖစ္ပါတယ္။ Driver ၊ Car ဆိုတာက objects ေတြျဖစ္ပါတယ္။ သူတုိ့ကို entities အေနႏွင့္ယူဆပါတယ္။ Driver တစ္ေယာက္မွာ နာမည္ပါမယ္၊ လိုင္စင္ပါမယ္ စသည္ျဖင့္ေပါ့ အဲ့တာေတြက driver ရဲ့ characteristics ေတြဘဲျဖစ္ပါတယ္။ ပံုမွာေတာ့ Driver ရဲ့ Name တစ္ခုကိုဘဲ attribute ယူထားတာဘဲျဖစ္ပါတယ္။ ထိုနည္းတူစြာပင္ Car လည္းအတူတူပင္ျဖစ္ပါတယ္။ Driver ႏွင့္ Car ၾကားမွာ ဘာ      ဆက္ႏြယ္မွူရွိလည္းဆိုရင္ ကားေမာင္းျခင္း (Drive) ဆိုတာက ဆက္သြယ္ေပးထားပါတယ္။ Drive Relationship မွာ attribute တစ္ခု ရွိေနတာ ကိုသတိျပဳမိမယ္ထင္ပါတယ္။ ဆိုလုိတာက trip ဆိုတာ Driver ေၾကာင့္ျဖစ္တာလညး္မဟုတ္ ဘူး၊ Car ေၾကာင့္ျဖစ္တာလည္း မဟုတ္ဘူး (Car ကိုဒီအတ္ိုင္းရပ္ထားရင္ေပါ့) ၊ Driver က Car ကို ေမာင္းသြားမွသာ Trip ဆိုတာ ျဖစ္ေပါေသာေၾကာင့္ Trip attribute ကို drive Relationship မွာ link ခ်ိတ္ေပးထား ျခင္းျဖစ္ပါတယ္။
Relationship အမ်ိဳးအစား သံုးမ်ိဳးရွိပါတယ္။
One-to-One
One-to-many
Many-to-many တိုဘဲျဖစ္ပါတယ္။ တကယ္လို့ Car တစ္စီး Driver တစ္ေယာက္ဘဲျဖစ္ရမယ္ လို့ constant ေပးမယ္ဆိုရင္ one-to-one relationship ျဖစ္ေပါပါတယ္။ အဲ့လိုမွ မဟုတ္ဘဲ Car တစ္စီး ကို Driver တစ္ေယာက္ထက္မက လို constant ေပးရင္ one-to-many relationship ျဖစ္ေပါပါတယ္။ 
By

Sunday, April 3, 2016

Introduction To Database

Database
                ယေန့ေခတ္မွာ database ဆိုတာ အရမ္းအေရးပါတဲ့ အပိုင္းတစ္ခုျဖစ္ပါတယ္။ database ဆိုတဲ့အသံုးအႏွဳန္းကို 1960 ေလာက္မွာ စတင္မိတ္ဆတ္ခဲ့ပါတယ္။ database ေတြ မေပါခင္မွာ file-based system ေတြကို အသံုးျပဳခဲ့ၾကပါတယ္။
           

File-based System

            File base system ဆိုတာ user အသံုးျပဳခ်င္ေသာ application programs ေတြစုစည္းေပးထားေသာ Service တစ္ခုဘဲျဖစ္ပါတယ္။ Program တစ္ခုကို data တစ္ခု ျဖစ္တဲ့အတြက္ limitation ေတြမ်ားစြာရွိေနပါတယ္။ ( Data Isolation, Data dependence, Data duplication,  Lack of flexibility )
File-based System ရဲအားနည္း ခ်က္ေတြေၾကာင့္ database System ကို စတင္ အသံုးျပဳခဲ့ပါတယ္။ DB System က file မွာ support မေပးတာကို ကို support ေပးထားပါတယ္။ (Data Sharing, Consistency of data, Security of data, Data independence, Increased concurrency,  Improved data backups and recovery )
File-based System

Data Model

          Database ကို စတင္ မေျပာခင္မွာ အရင္ဆံုး data model ဆိုတာကို သိထားဖိုလိုပါတယ္။ Real world က data (Raw) ေတြကို computerized ျဖစ္ေအာင္ ပံုေျပာင္းေပးရပါတယ္။ အဲလိုမ်ိဳး process ကို data modeling လုပ္တယ္လို ေျပာပါတယ္။ တစ္နည္းေျပာရရင္ data model ဆိုတာ user ႏွင့္ DBMS ၾကားက interface တစ္ခုဘဲ ျဖစ္ပါတယ္။
User ေတြက ေပးတဲ့ data ( real world data ) ေတြကို computerized မလုပ္ခင္မွာ model ပံုစံတည္ေဆာက္ေပးျပီးမွ ေျပာင္းေပးရပါတယ္။



Hierarchical data model

          Hierarchical data model ကို 1968 မွာ IBM ကေန စတင္ မိတ္ဆတ္ခဲ့ပါတယ္။ data set ေတြက hierarchical ပုံစံအတိုင္းတည္ရွိေနပါတယ္။
ပံုအရ A node ကို root node (parent မရွိေသာ node) လို့ေခါပါတယ္။ node ေတြၾကားမွာ link   ခ်ိတ္ေပးထားတာ ကိုေတာ့ branch လို့ေခါပါတယ္။ ေအာက္ဆံုး nodes (G,H) ေတြကိုေတာ့ leaf node (child မရွိေသာ node) လိုေျပာပါတယ္။ root node အပါအ၀င္ အျခားေသာ node ေတြအားလံုးကို segment လို့သံုးဆြဲေလ့ရွိပါတယ္။ Hierarchical data model ရဲ့ထူးျခားခ်က္က node တစ္ခုမွာ parent node တစ္ခုထက္ပိုမရွိပါဘူး။
( A parent can have more than one child ,but each child can’t have more than on parent )
အဲ့လိုမ်ိဳး parent-child relationship ေၾကာင့္ item တစ္ခု (node) ကိုသြားဖုိဆိုရင္ လမ္းေၾကာင္း တစ္ခုတည္းက ေနသာသြားလို့ရပါတယ္။


Network data model

          Network data model ကို 1963 မွာ IDS ကေနစင္ မိတ္ဆက္ခဲ့ပါတယ္။ Hierarchical data mode မွာ ေတာ့ node ေတြ စုစည္းထားတာကို segment လုိ့ေခါေပမယ့္ network data model မွာ node ေတြကို record လို့သံုးႏွဳန္းပါတယ္။အဲ့ record ေတြကို network ႏွင့္ခ်ိတ္ခ်က္ထားပါတယ္။ သူ့မွာ တစ္ခုပိုလားတာက level ဆိုတာပါဘဲ။ Hierarchy တစ္ခုခ်င္းစိ ကို level တစ္ခုလိ့ုသတ္မွတ္ပါတယ္။ root node ကေတာ့ level 0 ျဖစ္ပါတယ္။
Network data model ရဲ့ထူးျခားခ်က္က child တစ္ခုမွာ parent တစ္ခုထက္ မက ရွိေနႏိုင္ေနတာဘဲ။ အဲ့တာေၾကာင့္ item တစ္ခုကို သြားေတာ့မယ္ဆိုရင္ လမ္းေၾကာင္းေတြက တစ္ခုထက္မက ရွိေနႏိုင္ပါတယ္။ ဥပမာ H node ကိုသြားခ်င္ရင္ A-B-E-H ကေနသြားႏိုင္သလို ။ A-C-F-H / A-C-E-H တို့ကေနလည္း သြားႏိုင္ပါတယ္။


Relational data model

          Relational data model ကို 1970 မွာ IBM ကေနစတင္ မိတ္ဆတ္ခဲ့ပါတယ္။ Relational မွာ table (Row –Column) ကိုဘဲအသံုးျပဳပါတယ္။ Row က record အတြက္ျဖစ္ျပီးေတာ့ ။ Column ကေတာ့ data field အတြက္ဘဲျဖစ္ပါတယ္။ Row ေတြကို တစ္နည္းအားျဖင့္ tuple လုို့လည္းေခါပါေသးတယ္။ ထိုနည္းတူစြာ column ေတြကို
Attribute လုိ့သံုႏွုန္းပါတယ္။


By
Subscribe to: Posts (Atom)