फजी डायनामिक टेक्स्ट सर्च? इतना डरावना नहीं

# अलग करें <stdio.h>
# अलग करना <stdlib.h>
# अलग करें <string.h>

# अलग करना <libutil.h>

#ifdef WIN32
#include <crtdbg.h>
#endif

# फिर से बनाएं "sqlnode.h"
# फिर से बनाएं "sqlbif.h"
#include "wi.h"
# "Dk.h" को छोड़ दें

# पिन करें <math.h>
# जीतना "Caseutils.h"
#include "list_sort.h"
# अलग करें <assert.h>

// # शामिल करें <ksrvext.h>

स्थिर id_hash_t * ht_dict_ = NULL;
स्थिर dk_hash_t * ht_dict_by_id_ = NULL;
स्थिर id_hash_t * ht_triples_ = NULL;
स्थिर dk_mutex_t * dict_mtx_ = NULL;

संरचना श्रुत_चित__
char * word_;
size_t id_;
size_t count_;
size_t attr_;
};
typedef structure dict_item_s dict_item_t;

संरचना triple_item_s {
size_t wordid_;
संरचना triple_item_s * next_;
};
typedef structure triple_item_s triple_item_t;

संरचना triple_head_s {
lenmem_t lm_;
wchar_t data_ [4];
triple_item_t * list_;
};
typedef संरचना triple_head_s triple_head_t;

const wchar_t seps_ [] = L ",। \ t \ r \ n '\" = *!% ^:; ~ `<> +?"?
const wchar_t glues_ [] = L "() & @ # $: {} / \\ - [] _";

size_t next_wordid (Caddr_t * qst)
{
size_t _id = 0;
query_instance_t * q = (query_instance_t *) qst;
client_connection_t * cli = q-> qi_client;
query_t * stmt = NULL;
local_cursor_t * lc = NULL;
Caddr_t lerr = NULL;
Caddr_t * इरेट = & lerr;
char buf [1024];
स्प्रिंटफ (buf, "select अनुक्रम_next ('MRC_WORD_ID')");
अगर (NULL == (stmt = sql_compile (buf, cli, इरेट, 0)))
गोटो अंत;

if (NULL! = * * इरेट =
qr_rec_exec (stmt, cli, & lc, (query_instance_t *) qst, NULL
0)))
गोटो अंत;

अंत:
अगर (lc)
{
lc_next (lc);
_id = (size_t) unbox (lc_nth_col (lc, 0));
}
अगर (lc)
{
lc_free (lc);
lc = NULL;
}
अगर (stmt)
{
qr_free (stmt);
stmt = NULL;
}
वापसी _id;
}

size_t store_triple (Caddr_t * qst, size_t wordid, const wchar_t * त्रिभुज)
{
query_instance_t * q = (query_instance_t *) qst;
client_connection_t * cli = q-> qi_client;
query_t * stmt = NULL;
local_cursor_t * lc = NULL;
Caddr_t lerr = NULL;
Caddr_t * इरेट = & lerr;
char buf [1024];
wchar_t wlt [4];
wcsncpy (wlt, triple, 3);
wlt [3] = 0;

स्प्रिंटफ (buf, "--utf8_execs = yes \ n इन्सर्ट MRC_TRIPLES (TR_DATA, TR_WORDID) मानों (?)?") में डालें।
अगर (NULL == (stmt = sql_compile (buf, cli, इरेट, 0)))
गोटो अंत;

if (NULL! = * * इरेट =
qr_rec_exec (stmt, cli, & lc, (query_instance_t *) qst, NULL, 2,
": 0", box_wide_string (wlt), QRP_RAW,
": 1", box_num (wordid), QRP_RAW
)))
गोटो अंत;
{
char ** जगह = NULL;

triple_item_t * pitem = (triple_item_t *) dk_alloc_box_zero (sizeof (triple_item_t), DV_BIN);
triple_head_t * phead = (triple_head_t *) dk_alloc_box_zero (sizeof (triple_head_t), DV_BIN);

phead-> lm_.lm_length = sizeof (phead-> data_);
phead-> lm_.lm_memblock = (char *) phead-> data_;
memcpy (phead-> data_, wlt, sizeof (phead-> data_));

pitem-> wordid_ = wordid;

place = (char **) id_hash_get (ht_triples_, (Caddr_t) और phead-> lm_);
अगर (जगह)
{
triple_head_t * ohead = * (triple_head_t **) जगह;
pitem-> next_ = ohead-> list_;
ohead-> सूची_ = पिटेम;
}
अन्यथा
{
id_hash_set (ht_triples_, (Caddr_t) ((phead-> lm_), (caddr_t) & phead);
पीटम-> अगला_ = पिटेम;
}
}

अंत:
अगर (lc)
{
lc_free (lc);
lc = NULL;
}
अगर (stmt)
{
qr_free (stmt);
stmt = NULL;
}
वापसी 0;
}

wchar_t **
nv_split (wchar_t * tmp)
{
wchar_t ** arrest = NULL;
size_t len ​​= wcslen (tmp);
size_t ix = 0;
size_t i;
size_t cnt = 0;
के लिए (i = 0; मैं <लेन; मैं ++)
{
अगर (NULL! = wcschr (seps_, tmp [i]))
{
tmp [ix ++] = 0;
cnt ++;
}
अन्यथा
{
अगर (NULL == wcschr (glues_, tmp [i]))
tmp [ix ++] = mrc_toupper (tmp [i]);
}
}
tmp [ix] = 0;
cnt = 0;
के लिए (i = 0; मैं <लेन; मैं ++)
{
अगर (tmp [i])
{
cnt ++;
जबकि (i <len && 0! = tmp [++ i]);
}
}
यदि (cnt)
{
/ * और कई तत्वों में से एक या दो बार वेक्टर को आवंटित करें। * /
arr = dk_alloc_box ((cnt * sizeof (Caddr_t)), DV_ARRAY_OF_POINTER);

ix = 0;
के लिए (i = 0; मैं <लेन; मैं ++)
{
अगर (0! = tmp [i])
{
int loclen = wcslen (tmp + i);
((Caddr_t *) गिरफ्तार) [ix] = ((चार *) dk_alloc_box_zero ((loclen + 1) * sizeof (wchar_t), DV_LONG_WIDE);
memcpy (((Caddr_t *) गिरफ्तार) [ix ++], tmp + i, (loclen + 1) * sizeof (wchar_t));
जबकि (i <len && 0! = tmp [++ i]);
}
}
}
वापसी गिरफ्तार;
}

caddr_t
bif_nv_split (Caddr_t * qst, Caddr_t * इर_रेट, State_slot_t ** args)
{
char * me = "nv_split";
Caddr_t arrest = NULL;
Caddr_t arg = bif_arg_unrdf (qst, args, 0, me);
dtp_t dtp = DV_TYPE_OF (arg);
अगर (DV_DB_NULL == dtp || NULL == arg)
{
वापसी (NULL);
}
अगर (IS_STRING_DTP (dtp))
{
wchar_t * wide = box_utf8_as_wide_char (arg, NULL, strlen (arg), 0, DV_WIDE);
arr = (Caddr_t) nv_split (विस्तृत);
dk_free_box (चौड़ी);
वापसी गिरफ्तार;
}
अगर (IS_WIDE_STRING_DTP (dtp))
{
wchar_t * tmp = wcsdup ((const wchar_t *) arg);
arr = (Caddr_t) nv_split (tmp);
free (tmp);
वापसी गिरफ्तार;
}

{
sqlr_new_error ("22023", "SR007",
"फ़ंक्शन% s को तर्क के रूप में nvstring या NULL की आवश्यकता है, a
"प्रकार% s (% d) का कोई आर्ग नहीं",
मुझे, 1, DV_type_title (dtp), dtp);
}
वापसी गिरफ्तार;
}

caddr_t
bif_treat_nword (Caddr_t * qst, Caddr_t * इर_रेट, State_slot_t ** args)
{
char * me = "treat_nword";
Caddr_t arg = bif_arg_unrdf (qst, args, 0, me);
इंट लेन;
const wchar_t * wide = (const wchar_t *) arg;
const wchar_t * newwide = NULL;
wchar_t * tmpbuf;
size_t wordid = 0;
dtp_t dtp = DV_TYPE_OF (arg);
अगर (DV_DB_NULL == dtp)
{
वापसी (NULL);
}
अगर (IS_WIDE_STRING_DTP (dtp))
{
sqlr_new_error ("22023", "SR007",
"फ़ंक्शन% s को तर्क के रूप में nvstring या NULL की आवश्यकता है, a
"प्रकार% s (% d) का कोई आर्ग नहीं",
मुझे, 1, DV_type_title (dtp), dtp);
}
len = wcslen (चौड़ा);
tmpbuf = (wchar_t *) _ alloca (sizeof (wchar_t) * * (len + 3));
tmpbuf [0] = L "';
wcscpy (tmpbuf + 1, चौड़ी);
tmpbuf [len + 1] = L "';
tmpbuf [len + 2] = 0;
newwide = tmpbuf;

mutex_enter (dict_mtx_);
{
char * utf8 = box_wide_as_utf8_char ((const char *) चौड़ा, len, DV_LONG_STRING);
char ** जगह = NULL;

place = (char **) id_hash_get (ht_dict_, (Caddr_t) & utf8);
अगर (जगह)
{
dict_item_t * pitem = * (dict_item_t **) जगह;
pitem-> गिनती _ ++;
dk_free_box (utf8);
wordid = pitem-> id_;
}
अन्यथा
{
query_instance_t * q = (query_instance_t *) qst;
client_connection_t * cli = q-> qi_client;
query_t * stmt = NULL;
local_cursor_t * lc = NULL;
Caddr_t lerr = NULL;
Caddr_t * इरेट = & lerr;
char buf [1024];

dict_item_t * pitem = dk_alloc_box_zero (sizeof (dict_item_t), DV_BIN);
पिटम-> शब्द_ = utf8;
पिटम-> गिनती_ = 1;
wordid = next_wordid (qst);
पिटम-> आईडी_ = वर्डिड;
id_hash_set (ht_dict_, (Caddr_t) & utf8, (caddr_t) & pitem);
sethash ((void *) wordid, ht_dict_by_id_, (void *) pitem);

sprintf (buf, "--utf8_execs = MRC_WORDS (WD_ITSELF, WD_ID) मान (;?)" में सम्मिलित करें?
// कास्ट (charset_recode ('% s', 'UTF-8', '_WIDE_') nvarchar के रूप में) ", wordid, utf8);
अगर (NULL! = (stmt = sql_compile (buf, cli, इरेट, 0)))
{
* गलत =
qr_rec_exec (stmt, cli, & lc, (query_instance_t *) qst, NULL, 2,
": 0", box_wide_string (newwide), QRP_RAW,
": 1", box_num (wordid), QRP_RAW
);
// * इरेट = qr_rec_exec (stmt, cli, & lc, (query_instance_t *) qst, NULL, 0);
}
अगर (lc)
lc_free (lc);
अगर (stmt)
qr_free (stmt);

{
int len ​​= wcslen (newwide);
int i;
के लिए (i = 0; मैं <len-2; i ++)
{
store_triple (qst, wordid, newwide + i);
}
}
}
}
mutex_leave (dict_mtx_);
वापसी box_num (wordid);
}

int64
बॉक्स 2 लोंग (Caddr_t arg)
{
dtp_t dtp = DV_TYPE_OF (arg);
अगर (dtp == DV_SHORT_INT || dtp == DV_LONG_INT)
वापसी (int64) (unbox (arg));
और अगर (dtp == DV_SINGLE_FLOAT)
वापसी (int64) (unbox_float (arg));
और अगर (dtp == DV_DOUBLE_FLOAT)
वापसी (int64) (unbox_double (arg));
और अगर (dtp == DV_NUMERIC)
{
int64 dt;
num_to_int64 ((num_t) arg, & dt);
वापसी dt;
}
और अगर (dtp == DV_DB_NULL)
वापसी (int64) (0);
मुखर (को ०);
वापसी 0;
}

शून्य फ्लश_डिक्ट ()
{
char ** key = NULL;
char ** val = NULL;
id_hash_iterator_t हिट;
id_hash_iterator (& hit, ht_dict_);
जबकि (हिट_नेक्स्ट (और हिट, (Caddr_t *) और कुंजी, (Caddr_t *) * और वैल))
{
dk_free_box (* key);
dk_free_box (* val);
}
id_hash_clear (ht_dict_);
}

शून्य flush_triples ()
{
char ** key = NULL;
char ** val = NULL;
id_hash_iterator_t हिट;
id_hash_iterator (& hit, ht_triples_);
जबकि (हिट_नेक्स्ट (और हिट, (Caddr_t *) और कुंजी, (Caddr_t *) * और वैल))
{
triple_head_t * phead = * (triple_head_t **) val;
triple_item_t * pit = phead-> list_;

जबकि (गड्ढे)
{
triple_item_t * tmp = pit-> अगला_;
dk_free_box (गड्ढे);
गड्ढा = tmp;
}
dk_free_box (* val);
}
id_hash_clear (ht_triples_);
}

size_t reload_triples (query_instance_t * qst)
{
client_connection_t * cli = qst-> qi_client;
query_t * stmt = NULL;
local_cursor_t * lc = NULL;
Caddr_t lerr = NULL;
Caddr_t * इरेट = & lerr;
char buf [1024];

flush_triples ();

स्प्रिंटफ (buf, "select TR_DATA, MR__TRIPLES से TR_WORDID");
अगर (NULL! = (stmt = sql_compile (buf, cli, इरेट, 0)))
{
* गलत = qr_rec_exec (stmt, cli, & lc, (query_instance_t *) qst, NULL, 0);
अगर (lc)
{
int64 id = 0;
Caddr_t tmp = 0;
int64 cnt = 0;
char * utf8 = NULL;
char ** जगह = NULL;
lenmem_t lm;
triple_head_t * phead = NULL;
triple_head_t * ohead = NULL;
triple_item_t * pitem = NULL;

जबकि (lc_next (lc))
{
अगर (lc-> lc_error)
{
* गलत = box_copy_tree (lc-> lc_error);
तोड़;
}
id = box2long (lc_nth_col (lc, 1));
tmp = lc_nth_col (lc, 0);

pitem = (triple_item_t *) dk_alloc_box_zero (sizeof (triple_item_t), DV_BIN);
pitem-> wordid_ = (size_t) id;

lm.lm_length = sizeof (phead-> data_);
lm.lm_memblock = (caddr_t) tmp;

place = (char **) id_hash_get (ht_triples_, (Caddr_t) & lm);
अगर (जगह)
{
ohead = * (triple_head_t **) जगह;
pitem-> next_ = ohead-> list_;
ohead-> सूची_ = पिटेम;
}
अन्यथा
{
phead = (triple_head_t *) dk_alloc_box_zero (sizeof (triple_head_t), DV_BIN);
phead-> list_ = pitem;
phead-> lm_.lm_length = sizeof (phead-> data_);
phead-> lm_.lm_memblock = (Caddr_t) phead-> data_;
memcpy (phead-> data_, tmp, sizeof (phead-> data_));

pitem-> next_ = NULL;
id_hash_set (ht_triples_, (Caddr_t) और phead-> lm_, (Caddr_t) & phead);
}
}
}
}
अगर (lc)
lc_free (lc);
अगर (stmt)
qr_free (stmt);

वापसी 0;
}

caddr_t
bif_reload_dict (Caddr_t * qst, Caddr_t * इर_रेट, State_slot_t ** args)
{
query_instance_t * q = (query_instance_t *) qst;
client_connection_t * cli = q-> qi_client;
query_t * stmt = NULL;
local_cursor_t * lc = NULL;
Caddr_t lerr = NULL;
Caddr_t * इरेट = & lerr;
char buf [1024];

mutex_enter (dict_mtx_);
flush_dict ();

स्प्रिंटफ (buf, "WD_ID, WD_ITSELF, WD_COUNT को MRC_WORDS से चुनें");
अगर (NULL! = (stmt = sql_compile (buf, cli, इरेट, 0)))
{
* त्रुटी = qr_rec_exec (stmt, cli, & lc, (query_instance_t *) qst, NULL, 0);
अगर (lc)
{
int64 id = 0;
Caddr_t tmp = 0;
int64 cnt = 0;
char * utf8 = NULL;
char ** जगह = NULL;
size_t maxid = 0;

जबकि (lc_next (lc))
{
अगर (lc-> lc_error)
{
* गलत = box_copy_tree (lc-> lc_error);
तोड़;
}
id = box2long (lc_nth_col (lc, 0));
tmp = lc_nth_col (lc, 1);
cnt = box2long (lc_nth_col (lc, 2));
utf8 = box_wide_as_utf8_char (tmp, box_length (tmp) / sizeof (wchar_t) - 1, DV_LONG_STRING);

place = (char **) id_hash_get (ht_dict_, (Caddr_t) & utf8);
अगर (जगह)
{
मुखर (को ०);
}
अन्यथा
{
dict_item_t * pitem = dk_alloc_box_zero (sizeof (dict_item_t), DV_BIN);
पिटम-> शब्द_ = utf8;
पिटम-> गिनती_ = 1;
pitem-> id_ = (size_t) id;
अगर (अधिकतम <आईडी)
मैक्सिड = आईडी;
id_hash_set (ht_dict_, (Caddr_t) & utf8, (caddr_t) & pitem);
sethash ((void *) id, ht_dict_by_id_, (void *) pitem);
}
}
}
}
अगर (lc)
lc_free (lc);
अगर (stmt)
qr_free (stmt);

reload_triples (q);

mutex_leave (dict_mtx_);
वापसी 0;
}

// ------------------------------------------------ ---------------------------
// l_dist_raw ()
// स्थैतिक / स्थानीय कार्य !!!
//
// उद्देश्य: दो तारों (शब्दों) के लिए एल दूरी की गणना करता है।
//
// इनपुट्स: चार * str1, * str2 - इनपुट स्ट्रिंग्स (शब्द) कम्पेयर करने के लिए
// int len1, len2 - str1 amd str2 की लंबाई से कम है
// क्रमशः या MAX_LDIST_LEN।
// नोट! कोई त्रुटि जाँच नहीं की जाती है।
// स्टैक पर एरियर ओवरफ्लो होगा
// यदि या तो सीमा से बाहर है।
// आउटपुट: कोई नहीं
//
// रिटर्न: एल डिस्टेंस वैल्यू लौटा दी जाती है
//
// नोट, इस टिप्पणी शीर्षलेख के तुरंत बाद दो परिभाषित हैं कि
// केवल इस फ़ंक्शन द्वारा उपयोग किया जाता है।
//
// (सभी CAPS में मान LDIST.H हेडर फ़ाइल में परिभाषित किए गए हैं)
//
// ------------------------------------------------ ---------------------------
#define MAX_LDIST_LEN 40 // अधिकतम शब्द लेन टू कम्पेयर
#define MIN3 (a, b, c) (a <b??
(a <c। a: c): \
(b <c? b: c))

पूर्णांक
l_dist_raw (const wchar_t * str1, const wchar_t * str2, int len1, int len2)
{
int arr1 [MAX_LDIST_LEN + 1];
int arr2 [MAX_LDIST_LEN + 1];
int i, j;
अगर (len1> MAX_LDIST_LEN)
len1 = MAX_LDIST_LEN;
अगर (len2> MAX_LDIST_LEN)
len2 = MAX_LDIST_LEN;
के लिए (i = 0; मैं <= len2; i ++)
arr1 [i] = i;

के लिए (i = 1; मैं <= len1; i ++)
{
arr2 [0] = i;
के लिए (j = 1; j <= len2; j ++)
{
int score = (str1 [i-1] == str2 [j-1]); 0: 1;
int i1 = arr2 [j-1] +1;
int i2 = arr1 [j] +1;
int i3 = arr1 [j-1] + स्कोर;
arr2 [j] = MIN3 (i1, i2, i3); // arr2 [j-1] +1, arr1 [j] +1, arr1 [j] + स्कोर);
// d [(j-1) * n + i] +1, d [j * n + i-1] +1, d [(j-1) * n + i-1] + लागत);
}
memcpy (arr1, arr2, sizeof (int) * (len2 + 1));
}
वापसी arr2 [len2];
}

संरचना ipair_s {
पितृलंग id_;
ptrlong len_;
पॉट्रॉन्ग पॉज़_;
ptrlong score_;
};
typedef structure ipair_s ipair_t;

पूर्णांक
cmp_pairs (const void * a, const void * b)
{
const ipair_t * pa = * (const ipair_t **) a;
const ipair_t * pb = * (const ipair_t **) b;
अगर (pb-> id_ == पा-> id_)
वापसी पा-> स्कोर_ - पीबी-> स्कोर_;
वापसी पा-> id_ - pb-> id_;
}

int Compar_by_id (const void * a, const void * b, const void * arg)
{
ipair_t * pa = (ipair_t *) a;
ipair_t * pb = (ipair_t *) b;
वापसी पा-> id_ - pb-> id_;
}

int compar_by_score (const void * a, const void * b, const void * arg)
{
ipair_t * pa = (ipair_t *) a;
ipair_t * pb = (ipair_t *) b;
वापसी pb-> score_ - pa-> score_;
}

dk_set_t
load_oid_list (ipair_t ** words, query_instance_t * q, mem_pool_t * mp)
{
client_connection_t * cli = q-> qi_client;
/ * स्थिर * / query_t * stmt = NULL;
local_cursor_t * lc = NULL;
Caddr_t lerr = NULL;
Caddr_t * इरेट = & lerr;
dk_set_t out_list = NULL;
char buf [1024];
dk_set_t pair_list = NULL;
ipair_t * आइटम = NULL;
size_t i = 0;
size_t len ​​= box_length (शब्द) / sizeof (ipair_t *);
size_t cnt = 0;

अगर (NULL == stmt)
{
स्प्रिंटफ (buf, “DT_OID, MR__ATA से DT_POSITION जहां DT_WORDID =! ORD) का चयन करें;
if (NULL == (stmt = sql_compile_static (buf, / * बूटस्ट्रैप _ * / cli, इरेट, 0)))
वापसी NULL;
}
के लिए (i = 0; मैं <लेन; मैं ++)
{
size_t id;
ipair_t * जोड़ी = शब्द [i];
// प्रिंटफ ("\ n ---% d ----- \ n", जोड़ी-> आईडी_);
* इरेट = qr_rec_exec (stmt, cli, & lc, (query_instance_t *) q, NULL, 1,
": 0", box_num (जोड़ी-> id_), QRP_RAW);
अगर (NULL == lc)
जारी रखने के लिए;

जबकि (lc_next (lc))
{
अगर (lc-> lc_error)
{
* गलत = box_copy_tree (lc-> lc_error);
तोड़;
}
id = box2long (lc_nth_col (lc, 0));
आइटम = (ipair_t *) mp_alloc_box (mp, sizeof (ipair_t), DV_ARRAY_OF_LONG);
आइटम-> आईडी_ = आईडी;
आइटम-> लेन_ = जोड़ी-> लेन_;
आइटम-> pos_ = box2long (lc_nth_col (lc, 1));
आइटम-> स्कोर_ = जोड़ी-> स्कोर_;
mp_set_push (mp, & जोड़े_सूची, आइटम);
cnt ++;
// प्रिंटफ ("% डी", आईडी);
}
अगर (lc)
lc_free (lc);
}
अगर (stmt)
qr_free (stmt);

// अगर (stmt)
// qr_free (stmt);
// printf ("+% d +", cnt);
वापसी सूची_सॉर्ट (जोड़े_सूची, तुलना_बाहु, नल);
}

ipair_t **
get_word_candidates (wchar_t * arg)
{
ipair_t ** res = NULL;
dk_set_t ids_list = NULL;
Caddr_t arrest = NULL;

{
dk_hash_t * ht_ids = NULL;
int maxcount = 1;
size_t i;

wchar_t * word = (wchar_t *) arg;
wchar_t * pbuf = NULL;
size_t isnum = ((* शब्द)> = L'0 '&& (* शब्द) <= L'9');
size_t len ​​= wcslen (शब्द);
// int slen = len;
अगर (len <3 &&! isnum)
{
वापसी NULL;
}
word = (wchar_t *) box_copy (शब्द);
mrc_toupper_str (शब्द);

pbuf = (wchar_t *) _ alloca (sizeof (wchar_t) * * (len + 3));
pbuf [0] = L "';
wcscpy (pbuf + 1, शब्द);
pbuf [len + 1] = L "';
pbuf [len + 2] = L '\ 0';

ht_ids = hash_table_allocate (101);

mutex_enter (dict_mtx_);
के लिए (i = 0; मैं <(लेन); i ++)
{
char ** जगह = NULL;
lenmem_t lm;
triple_head_t * phead = NULL;
triple_item_t * pitem = NULL;
wchar_t trbuf [4];
trbuf [0] = mrc_toupper (pbuf [i]);
trbuf [1] = mrc_toupper (pbuf [i + 1]);
trbuf [2] = mrc_toupper (pbuf [i + 2]);
trbuf [3] = L '\ 0';

lm.lm_length = sizeof (phead-> data_);
lm.lm_memblock = (caddr_t) trbuf;

place = (char **) id_hash_get (ht_triples_, (Caddr_t) & lm);
अगर (जगह)
{
phead = * (triple_head_t **) जगह;
पीटम = फ़ेड-> सूची_;
जबकि (पिटेम)
{
int wordid = pitem-> wordid_;

int ptr = (int) gethash ((void *) wordid, ht_ids);
अगर (0 == ptr)
sethash ((शून्य *) वर्डिड, ht_ids, (शून्य *) 1);
अन्यथा
{
sethash ((void *) wordid, ht_ids, (void *) (++ ptr));
अगर (ptr> maxcount)
maxcount = ptr;
}

पीटम = पिटेम-> अगला_;
}
}
}
mutex_leave (dict_mtx_);

{
dk_set_t pair_list = NULL;
int nids = 0;
int mx = maxcount;
int nallids = ht_ids-> ht_count;
शून्य * कुंजी, * वैल;
dk_hash_iterator_t हिट;

maxcount = (maxcount + 1) / 2;
अगर (अधिकतम> = लेन)
maxcount = len - 1;
के लिए (dk_hash_iterator (और हिट, ht_ids);
dk_hit_next (& hit, (void **) & key, (void **) & val);
/ * * /)
{
int wordid = (int) key;
int cnt = (int) val;
अगर (cnt> = maxcount)
{
dict_item_t * pptr = (dict_item_t *) gethash ((शून्य *) शब्द, ht_dict_by_id_);
अगर (पीपीटीआर)
{
ipair_t * आइटम = NULL;
wchar_t buf [128];
size_t lbuf, dist, score;
box_utf8_as_wide_char ((Caddr_t) pptr-> word_, (caddr_t) buf, strlen (pptr-> word_), 127, DV_WIDE);
lbuf = wcslen (buf);
dist = l_dist_raw (शब्द, buf, लेन, lbuf);
स्कोर = 100 - (डिस्ट * * 100) / ((लेन> lbuf); लेन: lbuf);
// स्कोर = 100 - (डिस्ट * * 200) / (लेन + lbuf);
अगर (शब्द [0]! = buf [0])
स्कोर = (स्कोर * 3) >> 2;
// स्कोर = 100 - (डिस्ट * * 100) / ((लेन> lbuf); लेन: lbuf);
// wprintf (L "% s ->% s (% d) \ n", शब्द, buf, स्कोर);
आइटम = (ipair_t *) dk_alloc_box (sizeof (ipair_t), DV_ARRAY_OF_LONG);
आइटम-> आईडी_ = वर्डिड;
आइटम-> len_ = lbuf;
आइटम-> स्कोर_ = स्कोर;
dk_set_push (& जोड़े_सूची, आइटम);
nids ++;
}
मुखर (pptr);
}
}
अगर (जोड़े_सूची)
{
res = (ipair_t **) dk_set_to_array (जोड़े_सूची);
dk_set_free (जोड़े_सूची);
मुखर (nids == box_length (Res) / sizeof (शून्य *));
qort (रेस, nids, sizeof (शून्य *), cmp_pairs);
}
}
hash_table_free (ht_ids);
dk_free_box (शब्द);
}
वापसी Res;
}

caddr_t
bif_get_word_candidates (Caddr_t * qst, Caddr_t * इर_रेट, State_slot_t ** args)
{
char * me = "get_word_candidates";
ipair_t ** res = NULL;
dk_set_t ids_list = NULL;
Caddr_t arrest = NULL;
Caddr_t arg = bif_arg_unrdf (qst, args, 0, me);
dtp_t dtp = DV_TYPE_OF (arg);
अगर (DV_DB_NULL == dtp)
{
वापसी (NULL);
}
अगर (IS_WIDE_STRING_DTP (dtp))
{
sqlr_new_error ("22023", "SR007",
"फ़ंक्शन% s को तर्क के रूप में nvstring या NULL की आवश्यकता है, a
"प्रकार% s (% d) का कोई आर्ग नहीं",
मुझे, 1, DV_type_title (dtp), dtp);
}

अगर (0 == ht_dict _-> ht_count)
{
bif_reload_dict (qst, ir_ret, args);
}

res = get_word_candidates ((wchar_t *) arg);

ids_list = load_oid_list (res, (query_instance_t *) qst, NULL);
DO_SET (ipair_t *, आइटम, और आईडी_लिस्ट)
{
// प्रिंटफ ("% d", आइटम-> आईडी_);
dk_free_box (आइटम);
}
END_DO_SET ();

वापसी (Caddr_t) res;
}

caddr_t
bif_calc_similarity (Caddr_t * qst, Caddr_t * इर_रेट, State_slot_t ** args)
{
char * me = "calc_similarity";
Caddr_t arg1 = bif_arg_unrdf (qst, args, 0, me);
Caddr_t arg2 = bif_arg_unrdf (qst, args, 1, me);
dtp_t dtp1 = DV_TYPE_OF (arg1);
dtp_t dtp2 = DV_TYPE_OF (arg2);
अगर (DV_DB_NULL == dtp1 || DV_DB_NULL == dtp2)
{
वापसी (NULL);
}
if ((! IS_WIDE_STRING_DTP (dtp1)) || (!! IS_WIDE_STRING_DTP (dtp2))
{
sqlr_new_error ("22023", "SR007",
"फ़ंक्शन% s को nvstring या NULL को तर्क के रूप में, a) की आवश्यकता है;
}
{
wchar_t * str1 = (wchar_t *) arg1;
wchar_t * str2 = (wchar_t *) arg2;
int l1 = wcslen (str1);
int l2 = wcslen (str2);
int dist = l_dist_raw (str1, str2, l1, l2);
int स्कोर = 100 - (डिस्ट * 100) / (((l1> l2); l1: l2);
अगर (str1 [0]! = str2 [0])
स्कोर = (स्कोर * 3) >> 2;
वापसी स्कोर;
}
}
स्थिर int g_cnt = 0;
#if परिभाषित WIN32 और& परिभाषित (_DEBUG)
static_CrtMemState checkPt1;
#endif

लंबा sqrt_long (लंबा आर)
{
लंबे टी, बी, सी = 0;
मुखर (आर> = 0);

के लिए (बी = 0x10000000; बी! = 0; बी >> = 2)
{
t = c + b;
सी >> = 1;
यदि (t <= r)
{
आर = टी;
सी + = बी;
}
}
वापसी ©;
}

caddr_t
bif_query_phrase (Caddr_t * qst, Caddr_t * इर_रेट, State_slot_t ** args)
{
char * me = "query_phrase";
wchar_t ** words = NULL;
ptrlong * res = NULL;
wchar_t * tmp = NULL;
dk_set_t ids_list = NULL;
Caddr_t arrest = NULL;
Caddr_t arg = bif_arg_unrdf (qst, args, 0, me);
dtp_t dtp = DV_TYPE_OF (arg);
int len ​​= 0;
mem_pool_t * mp = mem_pool_alloc ();

#if 0 // परिभाषित WIN32 और& परिभाषित (_DEBUG)
_CrtCheckMemory ();
_CrtMemCheckpoint (& checkPt1);
#endif

// अगर (0 == (g_cnt% 1000))
// प्रिंटफ ("% d", g_cnt);
++ g_cnt;
अगर (DV_DB_NULL == dtp)
{
वापसी (NULL);
}
अगर (IS_STRING_DTP (dtp))
{
tmp = box_utf8_as_wide_char (arg, NULL, strlen (arg), 0, DV_WIDE);
words = nv_split (tmp);
dk_free_box (tmp);
}
और यदि (IS_WIDE_STRING_DTP (dtp))
{
tmp = wcsdup ((const wchar_t *) arg);
words = nv_split (tmp);
free (tmp);
}
अन्यथा
{
sqlr_new_error ("22023", "SR007",
"फ़ंक्शन% s को तर्क के रूप में nvstring या NULL की आवश्यकता है, a
"प्रकार% s (% d) का कोई आर्ग नहीं",
मुझे, 1, DV_type_title (dtp), dtp);
}

अगर (0 == ht_dict _-> ht_count)
{
bif_reload_dict (qst, ir_ret, args);
}

// mutex_enter (तानाशाही_mtx_);

अगर (शब्द)
{
size_t niters = box_length (शब्द) / sizeof (शून्य *);
dk_set_t परिणाम = NULL;
dk_set_t * iter_holders = mp_alloc_box (mp, niters * sizeof (dk_set_t), DV_ARRAY_OF_POINTER);
dk_set_t * iters = mp_alloc_box (mp, niters * sizeof (dk_set_t), DV_ARRAY_OF_POINTER);
size_t i = 0;
size_t ix = 0;
size_t cnt = 0;
size_t cnt1 = 0;
के लिए (i = 0; मैं <niters; i ++)
{
ipair_t ** Res = get_word_candidates ((wchar_t *) शब्द [i]);
अगर (Res)
{
iter_kers [ix] = load_oid_list (res, (query_instance_t *) qst, mp);
iters [ix] = iter_holders [ix];
ix ++;
dk_free_tree (res);
}
}
niters = ix;

अगर (niters)
{
int64 min_elem = 0;
int fin = 0;
(के लिए! फिन)
{
int bfound = 1;
size_t div = 1;
size_t स्कोर = 1;
size_t sumpos = 0;
size_t oldpos = 0;

अगर (iters [0])
तोड़;
min_elem = ((ipair_t *) iters [0] -> डेटा) -> id_;
के लिए (i = 0; मैं <niters; i ++)
{
अगर (iters [i])
{
ipair_t *ptr = (ipair_t *)iters[i]->data;
div *= 100;
score *= ptr->score_;
if (i)
{
sumpos += abs (oldpos — ptr->pos_);
}
oldpos = ptr->pos_;
if (ptr->id_ != min_elem)
{
bfound = 0;
}
if (ptr->id_ < min_elem)
{
min_elem = ptr->id_;
}
}
}
if (bfound)
{
ipair_t *item = mp_alloc_box(mp, sizeof(ipair_t), DV_BIN);
div /= 100;
score /= div;
if (niters > 1)
sumpos /= (niters — 1);
item->id_ = min_elem;
item->score_ = score/(1 + (sqrt_long(((100*sumpos)/5))/10));
mp_set_push(mp, &results, item);
cnt1++;

//printf («FOUND:%I64d %d\n», min_elem, score);
}
for (i = 0; i <niters; i++)
{
int bf = bfound;
while (iters[i] && (bf || min_elem == ((ipair_t *)iters[i]->data)->id_))
{
bf = 0;
iters[i] = iters[i]->next;
}
if (!iters[i])
{
fin = 1;
तोड़;
}
}
}
}

for (i = 0; i <niters; i++)
{
DO_SET (ipair_t *, item, &iter_holders[i])
{
cnt++;
//dk_free_box(item);
}
END_DO_SET ();
}
//dk_free_box (iters);
//dk_free_box (iter_holders);

//printf ("-%d-", cnt);
len = dk_set_length(results);
//if (len > 100)
{
results = list_sort (results, compare_by_score, NULL);
i = 0;
DO_SET (ipair_t *, entry, &results)
{
entry->len_ = (i >= 100)? 0:1;
मैं ++;
}
END_DO_SET();
len = (len>100)?100:len;
}
//results = list_sort (results, compare_by_id, NULL);
i = 0;
res = dk_alloc_box(len * 2 * sizeof(ptrlong), DV_ARRAY_OF_LONG);
DO_SET (ipair_t *, entry, &results)
{
if (entry->len_)
{
res[i++] = (entry->id_);
res[i++] = (entry->score_);
}
//dk_free_box(entry);
cnt1--;
}
END_DO_SET();
//dk_set_free (results);
dk_free_tree (words);
//printf("(%d)", cnt1);
}
//mutex_leave (dict_mtx_);
mp_free (mp);

#if 0//defined WIN32 && defined (_DEBUG)
// _CrtMemDumpAllObjectsSince( NULL );
_CrtMemDumpAllObjectsSince( &checkPt1 );
_CrtMemCheckpoint( &checkPt1 );
_CrtMemDumpStatistics( &checkPt1 );
_CrtCheckMemory( );
#endif
return (caddr_t)res;
}

शून्य
init_dict (void)
{
dict_mtx_ = mutex_allocate ();
ht_dict_ = id_hash_allocate (2039, sizeof (caddr_t), sizeof (caddr_t), strhash, strhashcmp);
ht_triples_ = id_hash_allocate (2039, sizeof (lenmem_t), sizeof (caddr_t), lenmemhash, lenmemhashcmp);
ht_dict_by_id_ = hash_table_allocate (2039);

bif_define («nv_split», bif_nv_split);
bif_define («treat_nword», bif_treat_nword);
bif_define («calc_similarity», bif_calc_similarity);
bif_define («reload_dict», bif_reload_dict);
bif_define («get_word_candidates», bif_get_word_candidates);
bif_define («query_phrase», bif_query_phrase);
}

void finit_dict()
{
flush_triples();
flush_dict();

hash_table_free (ht_dict_by_id_);
id_hash_free (ht_triples_);
id_hash_free (ht_dict_);
mutex_free (dict_mtx_);
}

extern int f_foreground;

पूर्णांक
main (int argc, char *argv[])
{
/*f_foreground = 1;
* FIXME: this could not be done in that way; this is a GPF on WIN32 and
* copy on write on linux; a fuinction from the shared object must be used
* to set it
* /
#ifdef MALLOC_DEBUG
dbg_malloc_enable ();
#endif
build_set_special_server_model ("Mircalo");
VirtuosoServerSetInitHook (init_dict);
वापसी VirtuosoServerMain (argc, argv);
}