program - xml tutorial pdf




मैं एक XML दस्तावेज़ को तिहाई(या, इससे भी बेहतर, n टुकड़ों में) कैसे विभाजित कर सकता/सकती हूं? (7)

मैं एक ऐसी भाषा का उपयोग करना चाहूंगा जिसे मैं परिचित हूं - जावा, सी #, रूबी, पीएचपी, सी / सी ++, यद्यपि किसी भी भाषा या स्यूडोकोड में उदाहरणों का स्वागत से अधिक है

बड़े वर्गों को विभाजित करने का सबसे अच्छा तरीका क्या छोटे वर्गों में अभी भी मान्य XML है? मेरे उद्देश्यों के लिए, उन्हें उन्हें लगभग तिहाई या चौथाई में विभाजित करने की आवश्यकता है, लेकिन उदाहरण प्रदान करने के लिए उन्हें एन घटकों में विभाजित करना अच्छा होगा।


अच्छी तरह से आप हमेशा शीर्ष-स्तरीय तत्वों को निकाल सकते हैं (चाहे आप चाहते हैं वह ग्रैन्युलरिटी आपके ऊपर निर्भर है)। सी # में, आप XmlDocument वर्ग का उपयोग करेंगे। उदाहरण के लिए, यदि आपकी XML फ़ाइल इस तरह से कुछ दिखाई देती है:

<Document>
  <Piece>
     Some text
  </Piece>
  <Piece>
     Some other text
  </Piece>
</Document>

तो आप सभी टुकड़ों को निकालने के लिए इस तरह से कोड का उपयोग करेंगे:

XmlDocument doc = new XmlDocument();
doc.Load("<path to xml file>");
XmlNodeList nl = doc.GetElementsByTagName("Piece");
foreach (XmlNode n in nl)
{
    // Do something with each Piece node
}

एक बार जब आप नोड्स प्राप्त कर लेते हैं, तो आप अपने कोड में उनके साथ कुछ कर सकते हैं, या आप नोड के पूरे पाठ को अपने XML दस्तावेज़ में स्थानांतरित कर सकते हैं और उस पर कार्रवाई कर सकते हैं जैसे कि यह XML का एक स्वतंत्र टुकड़ा था (इसे सहेजना वापस डिस्क पर, आदि)।


जैसा कि डैनीसमुर्फ़ यहां पर छूता है, यह सभी एक्सएमएल दस्तावेज़ की संरचना के बारे में है।
यदि आप केवल दो बड़े "शीर्ष स्तर" टैग्स, तो इसे एक तरह से विभाजित करने में सक्षम होना बहुत मुश्किल होगा, जिससे यह दोनों को एक साथ वापस मर्ज करने और इसे टुकड़े टुकड़े को वैध xml के रूप में पढ़ा जा सके।

DannySmurfs उदाहरण में बहुत से अलग टुकड़ों के साथ एक दस्तावेज़ को देखते हुए, यह काफी आसान होना चाहिए।
छद्म सी # में कुछ अजीब कोड:

int nrOfPieces = 5;
XmlDocument xmlOriginal = some input parameter..

// construct the list we need, and fill it with XmlDocuments..
var xmlList = new List<XmlDocument>();
for (int i = 0; i < nrOfPieces ; i++)
{
    var xmlDoc = new XmlDocument();
    xmlDoc.ChildNodes.Add(new XmlNode(xmlOriginal.FistNode.Name));
    xmlList.Add(xmlDoc);
}

var nodeList = xmlOriginal.GetElementsByTagName("Piece")M
// Copy the nodes from the original into the pieces..
for (int i = 0; i < nodeList .Count; i++)
{
    var xmlDoc = xmlList[i % nrOfPieces];
    var nodeToCopy = nodeList[i].Clone();
    xmlDoc.FirstNode.ChildNodes.Add(nodeToCopy);
}

यह आपको सही डॉक्स के साथ सही एक्सएमएल देना चाहिए और संभावनाओं को वापस एक साथ मर्ज करने की संभावना है।
लेकिन फिर, यह XML फ़ाइल पर निर्भर करता है।


मैं इस एक पर youphoric साथ जा रहा हूँ बहुत बड़ी फ़ाइलों के लिए SAX (या कोई अन्य स्ट्रीमिंग पार्सर) प्रसंस्करण में एक बड़ी मदद होगी। DOM का उपयोग करके आप केवल शीर्ष स्तर के नोड्स एकत्र कर सकते हैं, लेकिन आपको यह करने के लिए पूरे दस्तावेज़ को भी पार्स करना होगा ... एक स्ट्रीमिंग पार्सर और ईवेंट-आधारित प्रसंस्करण का उपयोग करके आपको उन नोड्स को "छोड़ें" जिन्हें आपको कोई दिलचस्पी नहीं है; प्रसंस्करण तेजी से बनाता है


यदि आप पूरी तरह से पर्ल से एलर्जी नहीं हैं, तो XML :: Twig xml_split नामक एक उपकरण के साथ आता है जो दस्तावेज़ को विभाजित कर सकता है, अच्छी तरह से बनाई गई XML अनुभाग का निर्माण कर सकता है। आप पेड़ के स्तर पर, आकार के द्वारा या एक XPath अभिव्यक्ति पर विभाजित कर सकते हैं।


ऐसा लगता है कि आप सी # और .NET 3.5 के साथ काम कर रहे हैं। मुझे कुछ पदों पर आ गया है जो एक XmlReader के साथ फ़ाइल स्ट्रीम पर एक एल्गोरिथ्म प्रकार का उपयोग करने का सुझाव देते हैं।

आपको पथ शुरू करने के लिए यहां कुछ ब्लॉग पोस्ट दिए गए हैं:


मैंने एक यूट्यूब वीडियो दिखाया है कि इनपुट और आउटपुट फाइलों के आकार की परवाह किए बिना एफओसीई के साथ एक्सएमएल फाइलों को कैसे विभाजित किया जा सकता है ( फर्स्टऑब्जेक्ट से मुफ्त एक्सएमएल संपादक) स्मृति की थोड़ी मात्रा का उपयोग कर।

इस CMarkup XML रीडर (पार्सर खींचें) और XML लेखक समाधान के लिए स्मृति उपयोग, उप-दस्तावेजों के आकार पर निर्भर करता है जो अलग-अलग इनपुट फाइल से आउटपुट फाइलों में या 16 KB के न्यूनतम ब्लॉक आकार में स्थानांतरित होते हैं।

split()
{
  CMarkup xmlInput, xmlOutput;
  xmlInput.Open( "50MB.xml", MDF_READFILE );
  int nObjectCount = 0, nFileCount = 0;
  while ( xmlInput.FindElem("//ACT") )
  {
    if ( nObjectCount == 0 )
    {
      ++nFileCount;
      xmlOutput.Open( "piece" + nFileCount + ".xml", MDF_WRITEFILE );
      xmlOutput.AddElem( "root" );
      xmlOutput.IntoElem();
    }
    xmlOutput.AddSubDoc( xmlInput.GetSubDoc() );
    ++nObjectCount;
    if ( nObjectCount == 5 )
    {
      xmlOutput.Close();
      nObjectCount = 0;
    }
  }
  if ( nObjectCount )
    xmlOutput.Close();
  xmlInput.Close();
  return nFileCount;
}

DOM का उपयोग करने वाले एक्सएमएल दस्तावेज़ों का विश्लेषण करना पैमाने पर नहीं है।

यह ग्रोवी- स्क्रिप्ट, स्टैक्स (एक्सएमआई के लिए स्ट्रीमिंग एपीआई) का प्रयोग कर रहा है, जो एक्सएमएल दस्तावेज़ को शीर्ष-स्तरीय तत्वों के बीच विभाजित करता है (जो उसी क्यूएन नाम को रूट-डॉक्यूमेंट के पहले बच्चे के रूप में साझा करता है)। यह बहुत तेज है, मनमाना बड़े दस्तावेज़ों को संभालता है और बहुत उपयोगी होता है जब आप बड़े बैच-फ़ाइल को छोटे टुकड़ों में विभाजित करना चाहते हैं।

जावा 6 या स्टैक्स एपीआई पर ग्रूवी की आवश्यकता होती है और कार्यान्वयन जैसे कि क्लासस्पैट में वुडस्टॉक्स

import javax.xml.stream.*

pieces = 5
input = "input.xml"
output = "output_%04d.xml"
eventFactory = XMLEventFactory.newInstance()
fileNumber = elementCount = 0

def createEventReader() {
    reader = XMLInputFactory.newInstance().createXMLEventReader(new FileInputStream(input))
    start = reader.next()
    root = reader.nextTag()
    firstChild = reader.nextTag()
    return reader
}

def createNextEventWriter () {
    println "Writing to '${filename = String.format(output, ++fileNumber)}'"
    writer = XMLOutputFactory.newInstance().createXMLEventWriter(new FileOutputStream(filename), start.characterEncodingScheme)
    writer.add(start)
    writer.add(root)
    return writer
}

elements = createEventReader().findAll { it.startElement && it.name == firstChild.name }.size()
println "Splitting ${elements} <${firstChild.name.localPart}> elements into ${pieces} pieces"
chunkSize = elements / pieces
writer = createNextEventWriter()
writer.add(firstChild)
createEventReader().each { 
    if (it.startElement && it.name == firstChild.name) {
        if (++elementCount > chunkSize) {
            writer.add(eventFactory.createEndDocument())
            writer.flush()
            writer = createNextEventWriter()
            elementCount = 0
        }
    }
    writer.add(it)
}
writer.flush()




xml