एमएस एक्सचेंज मेल डेटाबेस के लिए दर्शक लिखना (भाग 1)

एक बड़े, बड़े देश में, छोटे, बहुत छोटे लोग रहते थे। और सब कुछ ठीक था जब तक कि इस बड़े, या बड़े देश के केंद्र में एक गहरा, गहरा गड्ढा दिखाई नहीं दिया। खैर, मुझे कहना होगा, वह अकेले नहीं दिखाई दी और निश्चित रूप से, अभी नहीं, लेकिन कोई भी इसे याद नहीं रखेगा और यह किसी के लिए महत्वपूर्ण नहीं है।

मुख्य बात यह थी कि गड्ढे थे और यह बहुत बड़ा था, यहां तक ​​कि बहुत बड़ा, या अनंत, और अधिक सटीक रूप से कोई नहीं जानता था। लेकिन एक बड़े देश की सरकार को पता था कि गड्ढे के साथ कुछ किया जाना था, और यह अध्ययन करने और सो जाने का फैसला किया गया था। क्या उन सबसे सुंदर, निडर और साहसी, चतुर और सबसे चतुर पुरुषों और महिलाओं के लिए जो इस सुंदर राज्य में थे।

और सबसे अधिक निर्धारित के बारे में निर्धारित किया है। वे पढ़े और सो गए, सो गए और अध्ययन किया, अध्ययन किया, सो गए, सो गए, अध्ययन किया, और यह कई बार दोहराया नहीं गया, लेकिन कई बार।

ऐसा हुआ कि हमारे छोटे-से-सबसे अधिक नायकों को छोड़ दिया गया, या इसके बजाय उन्हें छोड़ना पड़ा, लेकिन गड्ढे बने रहे। लेकिन नए नायक आए, सिर्फ छोटे के रूप में, बल्कि वही, बहुत ही, और वही करने लगे।

सामान्य तौर पर, यह तब तक के लिए चलता रहा जब तक कि यह बना रहा। और एक ठीक दिन, गड्ढे गायब हो गए, हालांकि खुद, और कहीं पूरी तरह से अलग जगह पर दिखाई दिए, जहां उन्होंने अध्ययन करना शुरू किया और इसे काट दिया ...

सभी संयोग यादृच्छिक हैं, सब कुछ काल्पनिक है और ऐसा कुछ भी कभी नहीं हुआ है और यह वास्तविकता में नहीं हो सकता है! सच्चा, सच्चा, अच्छा या लगभग सच।

ऐसे ही एक गड्ढे की चर्चा बाद में की जाएगी। लेकिन कब से गोपनीयता नीति हम इसके केवल एक छोटे से टुकड़े को कवर करेंगे, जिसे केवल खुले स्रोतों और एक दस्तावेज एपीआई का उपयोग करके पहुँचा जा सकता है।

चूंकि सामग्री लगभग अनन्य होगी अनाज के विषय पर जानकारी।

क्या आपने कभी सोचा है कि एमएस एक्सचेंज सर्वर आपके सभी मेल को कहां संग्रहीत करता है, या यह उसके साथ सबसे निचले स्तर पर कैसे काम करता है? यहाँ इस बारे में थोड़ा है और मैं यहाँ लिखने जा रहा हूँ।

चेतावनी: इस विषय पर गहराई से जाने की कोशिश न करें, और आपका पूरा जीवन पर्याप्त नहीं होगा। मैंने चेतावनी दी।

परिचय

एमएस एक्सचेंज सर्वर (इसके बाद बस एक्सचेंज) Microsoft उत्पाद लाइन में फ्लैगशिप में से एक है। आप विकी में या आधिकारिक वेबसाइट पर इसके मुख्य कार्यों के बारे में पढ़ सकते हैं। संक्षेप में, यह मेल, कैलेंडर और अन्य उपयोगकर्ता डेटा के साथ काम करने के लिए एक "हारवेस्टर" है, जिसमें विभिन्न एमएस उत्पादों (SharePoint, TFS, आदि) के साथ पर्याप्त एकीकरण है।

लेकिन इस लेख के ढांचे में, हम इसमें रुचि नहीं लेंगे कि यह अंतिम उपयोगकर्ता को क्या प्रदान करता है, लेकिन इसे यह डेटा कहां से मिलता है और इसके लिए इसका उपयोग किस एपीआई से होता है। हम Exchange 2010 ( मेलबॉक्स सर्वर ) की मेलबॉक्स भूमिका पर मेलबॉक्स डेटाबेस को स्वतंत्र रूप से पढ़ने का प्रयास करेंगे।

एक्सचेंज के पास कई प्रवेश बिंदु ( सीएएस सर्वर ) हैं, जिसके माध्यम से उपयोगकर्ता अपने डेटा और कई प्रोटोकॉल का उपयोग कर सकता है जिसका वह इसके लिए उपयोग कर सकता है, उदाहरण के लिए, ओडब्ल्यूए, आरपीसी (आउटलुक), पीओपी 3 / आईएमएपी 4।

विधि के बावजूद, एक्सचेंज तक पहुंच प्राप्त करना मेलबॉक्स की भूमिका के लिए सभी अनुरोध भेजता है (एक्सचेंज 2007 से पहले यह एकमात्र भूमिका थी), जिसमें अन्य बातों के अलावा, उपयोगकर्ता मेलबॉक्स डेटाबेस शामिल हैं जो हम आज में रुचि रखते हैं। शारीरिक रूप से, ये डेटाबेस * .edb फ़ाइलों के अंदर हार्ड डिस्क पर स्थित होते हैं। वे उस निर्देशिका में Mailbox \ <डेटाबेस नाम> फ़ोल्डर में पाया जा सकता है जहां एक्सचेंज स्थापित किया गया था। इसके अलावा, लेनदेन लॉग और डेटाबेस जीवन चक्र से संबंधित अन्य फाइलें वहां रखी गई हैं, लेकिन हमें उनकी आवश्यकता नहीं होगी, हमारे लिए सबसे बुनियादी चीज * .edb है।

यदि आप थोड़ा खोदते हैं, तो आप पता लगा सकते हैं कि एक्सचेंज डेटाबेस की सामग्री तक पहुँचने के लिए एक्स्टेंसिबल स्टोरेज इंजन (ESE) का उपयोग करता है! और यदि आप चारों ओर खुदाई करते हैं, तो यह स्पष्ट हो जाता है कि ESE फ़ंक्शन का कार्यान्वयन लाइब्रेरी ese.dll (या esent.dll) में है। यह सभी Exchange कार्रवाई का मूल है । ईएसई डेटाबेस के साथ काम करने के लिए उपकरणों का एक व्यापक सेट प्रदान करता है। कार्यों, स्थिरांक, संरचनाओं और जो कुछ भी आवश्यक हो सकता है उसका विवरण यहां पाया जा सकता है । दुर्भाग्य से, यह दस्तावेज़ लंबे समय तक अपडेट नहीं किया गया है, इसलिए एक्सचेंज 2010 में दिखाई देने वाली कई विशेषताएं नहीं हैं, लेकिन हमें इस विषय में उनकी आवश्यकता नहीं है। आप Exchange मुख्य निर्देशिका के अंदर बिन फ़ोल्डर में ese.dll पा सकते हैं।

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

कुल में, हम जानते हैं कि एक्सचेंज अपने डेटाबेस को .bb एक्सटेंशन वाली फाइलों के रूप में, मेलबॉक्स बॉक्स भूमिकाओं पर संग्रहीत करता है, और उन्हें ESE (ese.dll) के लिए धन्यवाद देता है। यह हमारे लिए पर्याप्त है और हम कोडिंग शुरू कर सकते हैं।

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

प्रोग्रामिंग

ट्रेनिंग

सबसे पहले हमें चाहिए:

• विजुअल स्टूडियो 2008-2010
• एमएस एक्सचेंज सर्वर 2010 (कोई भी अन्य कार्य करेगा, लेकिन इस विषय में हम 2010 के बारे में बात करेंगे)
• C / C ++ का ज्ञान

बदले में, हम आधार बनाते हैं, जिसे हम पढ़ने की कोशिश करेंगे। ऐसा करने के लिए आप Exchange प्रबंधन कंसोल ( EMC ) का उपयोग कर सकते हैं। मैं प्रक्रिया का वर्णन नहीं करूंगा। इस विषय पर इंटरनेट पर बहुत सारी जानकारी है। हम इस डेटाबेस में (उसी EMC के माध्यम से) एक उपयोगकर्ता बनाएंगे ताकि इसमें कुछ सामग्री हो और इस उपयोगकर्ता द्वारा इस मेलबॉक्स में लॉग इन करके यह सत्यापित किया जाए कि सब कुछ सही तरीके से किया गया है, उदाहरण के लिए, OWA के माध्यम से। उसके बाद, हम मेलबॉक्स निर्देशिका में जाते हैं और अपने डेटाबेस के नाम के साथ एक फ़ोल्डर की तलाश करते हैं, और इसमें एक ईडीबी फ़ाइल। आधार को कॉपी करने से पहले, इसे EMC के माध्यम से अनमाउंट करें। सब कुछ, हमारे पास प्रयोगों के लिए एक आधार है। हम इसे कहीं और कॉपी करते हैं, उदाहरण के लिए, भविष्य की परियोजना की निर्देशिका के लिए।

बिन फ़ोल्डर से, ese.dll की प्रतिलिपि बनाएँ, धन्यवाद जिसके लिए हम डेटाबेस के साथ काम करेंगे।

विजुअल स्टूडियो में हम एक कंसोल C ++ प्रोजेक्ट बनाते हैं। यहाँ एक महत्वपूर्ण अति सूक्ष्म अंतर है, क्योंकि एक्सचेंज 2010 (सभी पिछले संस्करणों के विपरीत) में केवल 64 बिट संस्करण है, फिर हमें x64 समर्थन के साथ एक प्रोजेक्ट बनाना होगा, जैसा कि अन्यथा, हम बस अपने पता स्थान में ese.dll लोड नहीं कर सकते। इसलिए, एप्लिकेशन का परीक्षण करने के लिए, आपको ओएस के 64-बिट संस्करण की आवश्यकता है, आप निश्चित रूप से एक्सचेंज पर इसका परीक्षण कर सकते हैं, लेकिन इस उद्देश्य के लिए मैं विंडोज 7 के साथ अपने वर्कस्टेशन का उपयोग करूंगा। हम एपीआई के यूनिकोड संस्करण का भी उपयोग करेंगे, इसलिए यूनिकोड को प्रोजेक्ट में डिफ़ॉल्ट एन्कोडिंग बनाना बेहतर है।

और इसलिए, नए बनाए गए प्रोजेक्ट में, हम यह सुनिश्चित करते हैं कि x64 और यूनिकोड (सामान्य - यूनिकोड कैरेक्टर का उपयोग करें) के लिए समर्थन है। अब हम ESE के लिए मुख्य हेडर फाइल कनेक्ट करते हैं:

# अलग करें <esent.h>

यह फ़ाइल वीएस 2008 के बाद से एसडीके के साथ स्टूडियो के साथ आती है।
Stdafx.h में हम JET वर्जन (ESE) के साथ 2 डिफाइन जोड़ते हैं, और यह इंगित करते हैं कि हम API के यूनिकोड संस्करण का उपयोग करना चाहते हैं:

#define JET_UNICODE
#define JET_VERSION 0x0600

खैर, अब हमें यह निर्धारित करने की आवश्यकता है कि हम डेटाबेस से क्या प्राप्त करना चाहते हैं। ईएसई तालिकाओं, स्तंभों और पंक्तियों के साथ एक डेटाबेस है, जो वास्तव में हम इसे से निकालने की कोशिश करेंगे: तालिकाओं, स्तंभों और पंक्तियों। ऐसा करने के लिए, निम्नलिखित संरचनाएं तैयार करें:

typedef संरचना tagDBColumnsInfo
{
std :: wstring sColumnName ;
std :: वेक्टर < std :: wstring > sColumnValues ;
} SDBColumnInfo ;

typedef संरचना tagDBTableInfo
{
std :: wstring sTableName ;
std :: वेक्टर < SDBColumnInfo > sColumnInfo ;
} SDBTableInfo ;

typedef संरचना tagDBTablesInfo
{
std :: wstring sDBName ;
std :: वेक्टर < SDBTableInfo > sTablesInfo ;
} SDBTablesInfo ;

पहली बात यह है कि DLL को स्वयं लोड करना है, यह हमेशा की तरह करें, :: LoadLibrary (...) के माध्यम से।
हम ese.dll से फ़ंक्शन को गतिशील रूप से लोड करेंगे और हमें निम्नलिखित कार्यों की आवश्यकता होगी:

• JetInit
• JetCreateInstanceW
• JetBeginSessionW
• JetAttachDatabaseW
• JetOpenDatabaseW
• JetCloseDatabase
• JetDetachDatabaseW
• JetTerm
• JetSetSystemParameterW
• JetOpenTableW
• JetGetColumnInfoW
• JetRetrieveColumns
• JetMove
• JetGetTableColumnInfoW
• JetCloseTable
• JetGetSystemParameter

बेस ओपनिंग

हमारे द्वारा आवश्यक कार्यों को सफलतापूर्वक लोड करने के बाद, हम डेटाबेस को सीधे पढ़ना शुरू करते हैं। MSDN के अनुसार, आपको JET_paramDatabasePageSize (esent.h) पैरामीटर सेट करने के माध्यम से डेटाबेस पृष्ठ का आकार निर्दिष्ट करना होगा। यह वह जगह है जहाँ कठिनाई आती है। केवल EDB फ़ाइल वाले इस मान का पता लगाना असंभव है, लेकिन आपको इसे ठीक से निर्दिष्ट करने की आवश्यकता है अन्यथा डेटाबेस नहीं खुलेगा। यह eseutils (एक्सचेंज के साथ शामिल) के माध्यम से किया जा सकता है, लेकिन मैंने थोड़ा अलग रास्ता लिया और पता चला कि यह मूल्य एक्सचेंज के समान संस्करणों के लिए स्थिर है और हमेशा 4096 का गुणक है। यह प्रयोगात्मक रूप से पता चला था कि यह एक्सचेंज 2010 के लिए 32768 है ।

ठीक है, सबसे पहले, पृष्ठ का आकार निर्धारित करें:

JET_ERR jRes = _JetSetSystemParameter ( NULL , NULL , JET_paramDatabasePageSize, 32768 , NULL ) ;

JET_ERR सिर्फ एक लंबा है जिसमें एक त्रुटि कोड है। आप इस कोड को JetGetSystemParameter फ़ंक्शन (ala :: FormatMessage (...): के साथ टेक्स्ट विवरण में बदल सकते हैं।

JetGetSystemParameter ( m_instance, m_sesid, JET_paramErrorToString,
reinterpret_cast < JET_API_PTR * > ( & jeterror ) , cBuff, MAX_BUFFER_SIZE ) ;

त्रुटि कोड पार्स करने की सुविधा के लिए, मैं निम्नलिखित मैक्रो का उपयोग करता हूं (m_cLog मेरा आंतरिक लॉगिंग वर्ग है):

#define WRITE_TO_LOG_AND_RETURN_IF_ERROR (jeterror) \
अगर (जेटेरियर) {\ _
char cBuff [MAX_BUFFER_SIZE] = {0}; \
अगर (m_instance) _JetGetSystemParameter (m_instance, m_sesid, \ _
JET_paramErrorToString, reinterpret_cast <JET_API_PTR *> (& jeterror), cBuff, MAX_BUFFER_SIZE); \
m_cLog.write (m_sEDBPath, cBuff, jeterror, __FILE__, __LINE__); \
वापसी घाट; }

अब आपको Exchange पर विशिष्ट कॉलबैक को अक्षम करना होगा, जैसे हम उनके बारे में कुछ नहीं जानते:

jRes = _JetSetSystemParameter ( NULL , NULL , JET_paramDisableCallbacks, true , NULL ) ;

अगला, डेटाबेस के साथ काम करने के लिए एक नया उदाहरण (JET_INSTANCE m_instance) बनाएं:

jRes = _JetCreateInstance ( & m_instance, NULL ) ;

हम डेटाबेस के साथ काम करना शुरू करने के लिए बनाए गए उदाहरण को आरंभिक करते हैं:

jRes = _JetInit ( & m_instance ) ;

एक नया सत्र शुरू (JET_SESID m_sesid):

jRes = _JetBeginSession ( m_instance, & m_sesid, NULL , NULL ) ;

हम अपनी ईडीबी फ़ाइल कनेक्ट करते हैं:

jRes = _JetAttachDatabase ( m_sesid, L "Demo.edb" , JET_bitDbReadOnly ) ;

और इसे खोलें:

jRes = _JetOpenDatabase ( m_sesid, L "Demo.edb" , NULL , & m_dbid, JET_bitDbReadOnly ) ;

कुल मिलाकर, यदि सभी फ़ंक्शन JET_errSuccess वापस आ गए, तो डेटाबेस खुला है, जिसका अर्थ है कि आप सामग्री पढ़ना शुरू कर सकते हैं।

आगे कुछ कोड है। मैं इसे लाऊंगा क्योंकि इस विषय पर आप उसे दोपहर में आग के साथ नहीं पाएंगे।

हम तालिकाओं को सूचीबद्ध करते हैं

गणना करने के लिए, हम निम्नलिखित फ़ंक्शन लिखते हैं:

JET_ERR CJetDBReaderCore :: EnumRootTables ( SDBTablesInfo और sDBTablesInfo )
{
sDBTablesInfo। sDBName = m_sEDBPath ;
JET_ERR jRes = OpenTable ( ROOT_TABLE ) ;
अगर ( jRes == JET_errSuccess )
{
JET_COLUMNBASE sNameInfo,
sTypeInfo ;
अगर ( ReadFromTable ( ROOT_TABLE, NAME_COLUMN, sNameInfo ) &&
! ReadFromTable ( ROOT_TABLE, TYPE_COLUMN, sTypeInfo ) :
{
JET_RETRIEVECOLUMN sJetRC [ 2 ] ;
sJetRC [को ० ] । columnid = sNameInfo। कॉलम ;
sJetRC [को ० ] । cbData = sNameInfo। cbMax ;
sJetRC [को ० ] । itagSequence = 1 ;
sJetRC [को ० ] । चक्की = 0 ;
CHAR szName [ MAX_BUFFER_SIZE ] ;
sJetRC [को ० ] । pvData = szName ;

sJetRC [ 1 ] । columnid = sTypeInfo। कॉलम ;
sJetRC [ 1 ] । cbData = sTypeInfo। cbMax ;
sJetRC [ 1 ] । itagSequence = 1 ;
sJetRC [ 1 ] । चक्की = 0 ;
शब्द wType ;
sJetRC [ 1 ] । pvData = & wType ;

करना
{
jRes = GetColumns ( ROOT_TABLE, sJetRC, 2 ) ;
अगर ( jRes ! = JET_errSuccess ) वापसी jRes ;
अगर ( wType == 1 )
{
szName [ sJetRC [को ० ] । cbActual ] = 0 ;

SDBTableInfo sTableInfo ;
std :: string tmp ( szName ) ;
sTableInfo। sTableName असाइन करें ( tmp। शुरू ) ( ) , tmp। अंत ( ) ;

sDBTablesInfo। sTablesInfo । push_back ( sTableInfo ) ;
}

} जबकि ( ! TableEnd ( ROOT_TABLE ) ) ;
}

jRes = CloseTable ( ROOT_TABLE ) ;
}

वापसी jRes ;
}

जहां:

• ROOT_TABLE - "MSysObjects", चलो इस तालिका को रूट कहते हैं, क्योंकि इसमें डेटाबेस में अन्य सभी तालिकाओं की एक सूची है।
• NAME_COLUMN - "नाम", एक स्तंभ जिसमें सभी तालिकाओं के नाम हैं।
• TYPE_COLUMN - "प्रकार", एक स्तंभ जिसमें तालिका का प्रकार होता है।

जैसा कि आप कोड में देख सकते हैं, पहले हम रूट टेबल खोलते हैं, यह JetOpenTable फ़ंक्शन के माध्यम से किया जाता है:

JET_ERR CJetDBReaderCore :: OpenTable ( std :: wstring sTableName )
{
std :: map < std :: wstring , JET_TABLEID > :: const_iterator iter = m_tables। find ( sTableName ) ;
अगर ( iter == m_tables। अंत ( ) )
{
JET_TABLEID मेज़िद ( 0 ) ;
JET_ERR jRes = _JetOpenTable ( m_sesid, m_dbid, sableableName। C_str ( ) , NULL ,
0 , JET_bitTableReadOnly, & tableid ) ;
WRITE_TO_LOG_AND_RETURN_IF_ERROR_2 ( jRes )

m_tables [ sTableName ] = tableid ;
}

वापसी JET_errSuccess ;
}

आगे, हमें ReadFromTable के अंदर कॉलम के बारे में जानकारी मिलती है, क्योंकि सामग्री प्राप्त करने के लिए हमें उसकी आईडी चाहिए:

JET_ERR CJetDBReaderCore :: ReadFromTable (
std :: wstring sTableName,
std :: wstring sColumnName,
JET_COLUMNBASE & sColumnBase )
{
std :: map < std :: wstring , JET_TABLEID > :: const_iterator iter = m_tables। find ( sTableName ) ;
अगर ( iter ! = m_tables। समाप्ति ( ) )
{
JET_ERR jRes = _JetGetColumnInfo ( m_sesid, m_dbid, sTableName। C_str ( ) ।
sColumnName। c_str ( ) , और sColumnBase, sizeof ( JET_COLUMNBASE ) , JET_ColInfoBase ) ;
WRITE_TO_LOG_AND_RETURN_IF_ERROR_2 ( jRes )
}

वापसी JET_errSuccess ;
}

Id भरने के बाद JET_RETRIEVECOLUMN संरचना भरें, जिसके साथ हम तालिका नाम प्राप्त करने के लिए GetColumns के अंदर JetRetrieveColumns करते हैं:

JET_ERR CJetDBReaderCore :: GetColumns (
std :: wstring sTableName,
JET_RETRIEVECOLUMN * sJetRC,
INT एनकाउंट )
{
std :: map < std :: wstring , JET_TABLEID > :: const_iterator iter = m_tables। find ( sTableName ) ;
अगर ( iter ! = m_tables। समाप्ति ( ) )
{
JET_ERR jRes = _JetRetrieveColumns ( m_sesid, iter - > second, sJetRC, nCount ) ;
WRITE_TO_LOG_AND_RETURN_IF_ERROR_2 ( jRes )
}

वापसी JET_errSuccess ;
}

यही है, हमें तालिकाओं की सूची मिली है, चलो स्तंभों की सामग्री प्राप्त करने के लिए आगे बढ़ते हैं। प्रत्येक तालिका के लिए, हम इसमें स्तंभों की एक सूची प्राप्त करेंगे, और जैसा कि हम इसे प्राप्त करते हैं, हम इस जानकारी को अपनी संरचनाओं में सहेज लेंगे।

हम कॉलम सूचीबद्ध करते हैं

हम निम्नलिखित फ़ंक्शन लिखेंगे:

JET_ERR CJetDBReaderCore :: EnumColumns (
SDBTableInfo और sTableInfo,
std :: सूची < SColumnInfo > & sColumnsInfo )
{
अगर ( OpenTable ( sTableInfo। sTableName ) )
{
JET_COLUMNLIST sColumnInfo ;
GetTableColumnInfo ( sTableInfo। STableName , और sColumnInfo ) ;
MoveToFirst ( sTableInfo। STableName ) ;

char szNameBuff [ MAX_BUFFER_SIZE ] ;
करना
{
SCOLumnInfo ci ;
JET_RETRIEVECOLUMN sJetRC [ 4 ] ;

sJetRC [को ० ] । columnid = sColumnInfo। columnidcolumnname ;
sJetRC [को ० ] । cbData = sizeof ( szNameBuff ) ;
sJetRC [को ० ] । itagSequence = 1 ;
sJetRC [को ० ] । चक्की = 0 ;
sJetRC [को ० ] । pvData = szNameBuff ;

sJetRC [ 1 ] । columnid = sColumnInfo। कॉलमिडॉल्किनिड ;
sJetRC [ 1 ] । cbData = sizeof ( DWORD ) ;
sJetRC [ 1 ] । itagSequence = 1 ;
sJetRC [ 1 ] । चक्की = 0 ;
sJetRC [ 1 ] । pvData = & ci। dwId ;

sJetRC [ 2 ] । columnid = sColumnInfo। स्तंभलेख ;
sJetRC [ 2 ] । cbData = sizeof ( DWORD ) ;
sJetRC [ 2 ] । itagSequence = 1 ;
sJetRC [ 2 ] । चक्की = 0 ;
sJetRC [ 2 ] । pvData = & ci। dwType ;

sJetRC [ 3 ] । columnid = sColumnInfo। columnidcbMax ;
sJetRC [ 3 ] । cbData = sizeof ( DWORD ) ;
sJetRC [ 3 ] । itagSequence = 1 ;
sJetRC [ 3 ] । चक्की = 0 ;
sJetRC [ 3 ] । pvData = & ci। dwMaxSize ;

GetColumns ( sTableInfo। STableName , sJetRC, 4 ) ;

ci। sName असाइन करें ( reinterpret_cast < wchar_t * > ( sJetRC [ 0 ] । pvData ) , sJetRC [ 0 ] । cbActual / 2 ) ;

SDBColumnInfo sDBColumnInfo ;
sDBColumnInfo। sColumnName = ci। sName ;

sColumnsInfo। push_back ( ci ) ;
sTableInfo। sColumnInfo । push_back ( sDBColumnInfo ) ;
}
जबकि ( TableEnd ( sTableInfo। sTableName ) ) ;

CloseTable ( sTableInfo। STableName ) ;
}

वापसी JET_errSuccess ;
}

यहां हम टेबल को फिर से खोलते हैं, लेकिन रूट नहीं है, लेकिन वह जो हमें पिछले चरण में मिला था।

इसके बाद, आपको सभी कॉलमों के बारे में जानकारी प्राप्त करने की आवश्यकता है, इसके लिए हमें पहले एक पॉइंटर प्राप्त करना होगा और इसके द्वारा अंतिम एक पर जाना होगा:

JET_ERR CJetDBReaderCore :: MoveToFirst ( std :: wstring sTNIS )
{
std :: map < std :: wstring , JET_TABLEID > :: const_iterator iter = m_tables। find ( sTableName ) ;
if ( iter ! = m_tables। end ( ) ) // यदि पहले से ही खुला है
{
JET_ERR jRes = _JetMove ( m_sesid, iter - > second, JET_MoveFirst, 0 ) ;
BOOL bIsEmpty = ( jRes == JET_errNoCurrentRecord ) ;
अगर ( bIsEmpty ) रिटर्न jRes ; // खाली हो तो इनग्नोर करें
WRITE_TO_LOG_AND_RETURN_IF_ERROR_2 ( jRes ) ;
}

वापसी NO_ERROR ;
}

JET_ERR CJetDBReaderCore :: GetTableColumnInfo ( WP
std :: wstring sTableName,
JET_COLUMNLIST * pCl,
BOOL bReplaceOld )
{
JET_ERR jRes = JET_errSuccess ;
std :: map < std :: wstring , JET_TABLEID > :: itter iter = m_tables। find ( sTableName ) ;
अगर ( iter ! = m_tables। समाप्ति ( ) )
{
jRes = _JetGetTableColumnInfo ( m_sesid, iter - > दूसरा, NULL , pCl,
sizeof ( JET_COLUMNLIST ) , JET_ColInfoList ) ;
WRITE_TO_LOG_AND_RETURN_IF_ERROR_2 ( jRes )

if ( bReplaceOld ) // यदि आपको अंतिम बार खुली तालिका की आवश्यकता नहीं है
{
jRes = CloseTable ( sTableName ) ;
m_tables [ sTableName ] = pCl - > टेबलिड ;
}
अन्यथा
{
jRes = _JetCloseTable ( m_sesid, pCl - > tableid ) ;
WRITE_TO_LOG_AND_RETURN_IF_ERROR_2 ( jRes )
}
}

वापसी jRes ;
}

क्षमा करें, पोस्ट का पहला संस्करण काट दिया गया था, और मैंने समय पर प्रतिक्रिया देने का प्रबंधन नहीं किया था, जाहिर है कि लेख के आकार पर किसी तरह का प्रतिबंध है, इसलिए इसे दो भागों में विभाजित किया जाएगा।
जारी रखने के लिए ...

अगले भाग में, हम आधार को पढ़ेंगे, निष्कर्ष निकालेंगे, और डेटा के एक उदाहरण को देखेंगे जो आधार का "फटा हुआ" हो सकता है।

PS यह कोड पोस्ट के लिए एक अनुकूलित और कम किया गया संस्करण है। इसलिए, कोड में कुछ खामियां हैं, या छंटनी की कार्यक्षमता के स्थानों में गैग हैं। कृपया उन पर ध्यान न दें, यह उत्पादन नहीं है, लेकिन मैं काम करने के उदाहरण दिखाना चाहता था। कोड पूरी तरह से काम कर रहा है और लिखा गया है ताकि इसे इंटरनेट पर रखा जा सके और एक ही समय में पेज पर सभी जगह "खाएं" नहीं। आपकी समझ के लिए धन्यवाद।

पीपीएस मैं समझता हूं कि, बारीकियों के कारण, यह जानकारी लोगों की एक विस्तृत श्रृंखला के लिए उपयोगी होने की संभावना नहीं है, लेकिन अगर यह एक व्यक्ति की भी मदद करता है, तो मुझे खुशी होगी और इस पद पर बिताया गया समय समाप्त हो जाएगा।

संबंधित लिंक

1. MSDN पर एक्स्टेंसिबल स्टोरेज इंजन
2. रूसी में एक लेख (ईएसई एपीआई का उपयोग करने के बारे में RuNet में एकमात्र लेख)
3. ईएसई फ़ीचर उदाहरण