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




xml tutorial pdf (8)

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

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

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

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


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


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 के लिए, मैं हमेशा ईवेंट आधारित प्रसंस्करण का प्रशंसक रहा हूं। हो सकता है कि यह मेरी जावा पृष्ठभूमि है, लेकिन मैं वास्तव में SAX की तरह ही करता हूं। आपको अपने खुद के राज्य प्रबंधन की ज़रूरत है, लेकिन एक बार जब आप पिछले हो जाते हैं, तो यह XML को पार्स करने का एक बहुत ही कुशल तरीका है।

http://saxdotnet.sourceforge.net/


जैसा कि डैनीसमुर्फ़ यहां पर छूता है, यह सभी एक्सएमएल दस्तावेज़ की संरचना के बारे में है।
यदि आप केवल दो बड़े "शीर्ष स्तर" टैग्स, तो इसे एक तरह से विभाजित करने में सक्षम होना बहुत मुश्किल होगा, जिससे यह दोनों को एक साथ वापस मर्ज करने और इसे टुकड़े टुकड़े को वैध 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 का उपयोग करके आप केवल शीर्ष स्तर के नोड्स एकत्र कर सकते हैं, लेकिन आपको यह करने के लिए पूरे दस्तावेज़ को भी पार्स करना होगा ... एक स्ट्रीमिंग पार्सर और ईवेंट-आधारित प्रसंस्करण का उपयोग करके आपको उन नोड्स को "छोड़ें" जिन्हें आपको कोई दिलचस्पी नहीं है; प्रसंस्करण तेजी से बनाता है


यह पूरी फाइल एक बार में पढ़ा जाएगा। मेरे अनुभव में, हालांकि, यदि आप बस फाइल पढ़ रहे हैं, कुछ प्रसंस्करण कर रहे हैं (यानी, इसे तोड़ना) और फिर अपने काम के साथ आगे बढ़ते हुए, XmlDocument इस माध्यम से जा रहा है कि इसे बनाने / पढ़ना / एकत्रित चक्र इतनी जल्दी है कि यह संभवतः कोई बात नहीं करेगा

बेशक, यह उस पर निर्भर करता है जो "बड़ी" फ़ाइल है अगर यह एक 30 एमबी एक्सएमएल फ़ाइल है (जो मैं एक XML फ़ाइल के लिए बड़ा विचार करेगा), यह शायद कोई अंतर नहीं करेगा यदि यह 500 एमबी एक्सएमएल फ़ाइल है, तो XmlDocument का उपयोग करके सिस्टम पर एक महत्वपूर्ण राशि के बिना बेहद समस्याग्रस्त हो जाएगा (उस मामले में, हालांकि, मैं तर्क देता हूं कि मैन्युअल रूप से फ़ाइल को 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;
}




xml