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

हेलो रीडर्स हबरहाब!

यहीं से शुरू हुई पोस्ट का अंत।

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

पिछली पोस्ट में, मैंने तालिका में अगले कॉलम पर जाने के लिए जिम्मेदार फ़ंक्शन नहीं जोड़ा था, साथ ही SCOLumnInfo संरचना का वर्णन भी किया है, यहां वे हैं:

typedef संरचना tagColumnInfo
{
DWORD dwId ;
std :: wstring sName ;
DWORD dwType ;
DWORD dwMaxSize ;
} SColumnInfo ;

बूल CJetDBReaderCore :: TableEnd ( std :: wstring sTableName )
{
std :: map < std :: wstring , JET_TABLEID > :: const_iterator iter = m_tables। find ( sTableName ) ;
अगर ( iter ! = m_tables। समाप्ति ( ) )
{
अगर ( _JetMove ( m_sesid, iter - > दूसरा, JET_MoveNext, 0 )
{
सच लौटना ;
}
और झूठे वापस ;
}

सच लौटना ;
}

तदनुसार, जब अगले तत्व तक ले जाना संभव नहीं है, तो यह एक संकेत है कि तालिका समाप्त हो गई है ।

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

स्तंभों में सेल मान प्राप्त करें

हम निम्नलिखित कार्य लिखते हैं:

JET_ERR CJetDBReaderCore :: EnumColumnsValues ​​और
SDBTableInfo और sTableInfo,
std :: सूची < SColumnInfo > & sColumnsInfo )
{
typedef std :: basic_string < बाइट > CByteArray ;
JET_ERR jRes = OpenTable ( sTableInfo। STableName ) ;
अगर ( jRes == JET_errSuccess )
{
JET_COLUMNLIST sColumnInfo ;
jRes = GetTableColumnInfo ( sTableInfo। sTableName , & sColumnInfo, FALSE ) ;
अगर ( jRes ! = JET_errSuccess ) वापसी jRes ;

अगर ( MoveToFirst ( sTableInfo। sTableName ) )
{
std :: वेक्टर < CByteArray > धारकों ( sColumnsInfo। size ( ) ) ;
std :: वेक्टर < CByteArray > :: iterator HolderIt = धारकों। शुरू ( ) ;

std :: वेक्टर < JET_RETRIEVECOLUMN > पंक्ति ( sTableInfo। sCumnumnInfo । आकार ( ) ) ;
std :: वेक्टर < JET_RETRIEVECOLUMN > :: पुनरावृति इट = पंक्ति। शुरू ( ) ;

std :: सूची < SColumnInfo > :: const_iterator ColumnInfoIt
= sColumnsInfo। शुरू ( ) ;

for ( int nColNum = 0 ; ColumnInfoIt ! = sColumnsInfo। अंत ) ( )
++ ColumnInfoIt, ++ It, ++ HolderIt, ++ nColNum )
{
DWORD dwMaxSize = ColumnInfoIt - > dwMaxSize ? ColumnInfoIt - > dwMaxSize :
MAX_BUFFER_SIZE ;
यह - > कॉलमिड = ColumnInfoIt - > dwId ;
यह - > cbData = dwMaxSize ;
धारक - > असाइन करें ( dwMaxSize, ' \ 0 ' ) ;
यह - > pvData = const_cast < byte * > ( धारक - > डेटा ( ) ) ;
यह - > itagSequence = 1 ;
}

करना
{
GetColumns (
sTableInfo। STableName , और रो [ 0 ] ,
static_cast < INT > ( पंक्ति आकार । ( ) ) ;

ColumnInfoIt = sColumnsInfo। शुरू ( ) ;
int iSubItem = 0 ;
के लिए ( यह = पंक्ति शुरू । ) ; यह = ! पंक्ति अंत ( ) ; ++ यह ;
++ ColumnInfoIt, ++ iSubItem )
{
अगर ( * यह ) । cbActual )
{
std :: wstring s ;
std :: string tmp ;
wchar_t बफ [ 16 ] ;

स्विच ( ColumnInfoIt - > dwType )
{
मामला JET_coltypBit :
s = * reinterpret_cast < byte * > ( ( * It। pvData ) ? एल "ट्रू" : एल "गलत" ;
तोड़ना ;
मामला JET_coltypText :
tmp। असाइन करें ( reinterpret_cast < char * > ( ( * It ) । pvData ) , ( * It। cbActual ) ;
रों। असाइन करें ( tmp। शुरू ) ( ) , tmp। अंत ( ) ;
तोड़ना ;
मामला JET_coltypLongText :
रों। असाइन करें ( पुनर्व्याख्या_कास्ट करें < wchar_t * > ( ( * यह ) । pvData ) ।
( * यह ) । cbActual / sizeof ( wchar_t ) ) ;
तोड़ना ;
मामला JET_coltypUnsignedByte :
s = _ltow ( * static_cast < byte * > ( ( * It ) । pvData ) , बफ़ , 10 ) ;
तोड़ना ;
मामला JET_coltypShort :
s = _ltow ( * static_cast < short * > ( ( * It ) । pvData ) , बफ़ , 10 ) ;
तोड़ना ;
मामला JET_coltypLong :
s = _ltow ( * static_cast < long * > ( ( * It ) । pvData ) , बफ़ , 10 ) ;
तोड़ना ;
मामला JET_coltypGUID :
wchar_t wszGuid [ 64 ] ;
:: StringFromGUID2 ( * reinterpret_cast < const GUID * > ( * * ) । Pvataata ) ,।
wszGuid, sizeof ( wszGuid ) ) ;
USES_CONVERSION;
s = wszGuid ;
तोड़ना ;
}

sTableInfo। sColumnInfo [ iSubItem ] । sColumnValues । push_back ( s ) ;
}

और sTableInfo। sColumnInfo [ iSubItem ] । sColumnValues । push_back ( L "<खाली>" ) ;

}
}
जबकि ( TableEnd ( sTableInfo। sTableName ) ) ;
}

jRes = CloseTable ( sTableInfo। sTableName ) ;
}

वापसी jRes ;
}

हम सभी लाइनों के माध्यम से जाएंगे और प्रत्येक के लिए हम कोशिकाओं के मूल्य को घटाएंगे। और चलो कर्सर को उचित स्थिति में रखकर पहले तत्व पर जाएं (MoveToFirst फ़ंक्शन, पिछली पोस्ट देखें)।

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

यानी:

• संक्षिप्तता के लिए, हम घोषणा करते हैं:

  typedef std :: basic_string < बाइट > CByteArray

• डेटा के लिए धारक बनाएँ, वे डेटाबेस से जानकारी प्राप्त करेंगे:

  std :: वेक्टर < CByteArray > धारकों ( sColumnsInfo। size ( ) ) ;

• और फिर चक्र में हम मेमोरी के टुकड़ों को जोड़ेंगे जहां डेटा और हमारे धारक वापस लौट आएंगे, और इसके लिए हम सभी सूचनाओं को रखने के लिए सबसे पहले पर्याप्त मेमोरी आवंटित करते हैं (कॉलमों को सूचीबद्ध करते समय हमें अधिकतम डेटा आकार मिला है):

  धारक - > असाइन करें ( dwMaxSize, ' \ 0 ' ) ;
  यह - > pvData = const_cast < byte * > ( धारक - > डेटा ( ) ) ;

• और अब लूप में हम प्रत्येक कॉलम के लिए अपने वेक्टर JET_RETRIEVECOLUMN के लिए जानकारी वापस करेंगे, जो धारकों के लिए आवंटित मेमोरी का उपयोग करता है:

  GetColumns ( sTableInfo। STableName , & Row [ 0 ] , static_cast << >> ( Row। Size ( ) ) ) ;

नतीजतन, हम तालिका से एक पंक्ति को घटाते हैं। लेकिन कब से डेटा बाइट्स की एक सरणी है, इसे कुछ और पठनीय में बदलने की आवश्यकता है, इसलिए हम कोशिकाओं को उनके प्रकारों के आधार पर पार्स करने का प्रयास करेंगे। इस उदाहरण में, निम्न प्रकारों का विश्लेषण किया जाता है (सबसे स्पष्ट रूप में):

• JET_coltypBit
• JET_coltypText
• JET_coltypLongText
• JET_coltypUnsignedByte
• JET_coltypShort
• JET_coltypLong
• JET_coltypGUID

ईएसई में उपलब्ध प्रकारों का विवरण यहां पाया जा सकता है ।

निष्कर्ष

इसलिए हमने मेल डेटाबेस के एक दर्शक को लिखा! यदि आप इन अंतहीन तालिकाओं में खुदाई करना शुरू करते हैं, तो आप बहुत सारी दिलचस्प चीजें पा सकते हैं, उदाहरण के लिए, पिछले सभी संस्करणों की तुलना में एक्सचेंज 2010 में काफी बदलाव आया है और बहुत कुछ।

हमने जो लिखा है वह एक महत्वपूर्ण दोष है: दृश्यता। हमने संरचनाओं का एक गुच्छा भर दिया जो किसी भी तरह से प्रदर्शित नहीं हुआ। यानी आपको एक GUI प्रोग्राम लिखना होगा जो इन सभी संरचनाओं की सामग्री को स्पष्ट रूप से दिखाता है। इसे लिखना कठिन नहीं होना चाहिए, क्योंकि यह सरल ग्रिड का एक सेट होगा; संरचना का लाभ पहले से ही तैयार है और भरा हुआ है, अर्थात, मोटे तौर पर बोलना, यह केवल प्रिंट करने के लिए रहता है। मैं इस तरह के तालिकाओं के कुछ उदाहरण नीचे दूंगा।

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

यह कहां काम आ सकता है? यह केवल उन मामलों में उपयोगी हो सकता है जहां एक और एपीआई काम नहीं करता है या कुछ आवश्यकताओं से संतुष्ट नहीं है, उदाहरण के लिए, एक प्रदर्शन की आवश्यकता। ऐसे कार्यों के उदाहरण हो सकते हैं: एंटीवायरस, ऑडिट सिस्टम, माइग्रेशन और रिकवरी।

अंत में, प्राप्त आंकड़ों के दो छोटे उदाहरण।
डेटाबेस में तालिकाओं की सूची का एक टुकड़ा:


फ़ोल्डर्स और उनके प्रकारों की सूची:


पढ़ने और अपना समय लेने के लिए धन्यवाद!

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

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

संबंधित लिंक

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