// 只创建带结果集的ReversePolishItem对象，并push到栈里
// parameter:
// oResult 结果集
// return:
// void
public void PushResultSet(DpResultSet oResult)
{
ReversePolishItem oItem = new ReversePolishItem(null,
oResult);
Add(oItem);
}
public DpResultSet GetResultSet(string strResultSetName,
bool bAutoCreate = true)
{
if (String.IsNullOrEmpty(strResultSetName) == true)
{
strResultSetName = "default";
}
strResultSetName = strResultSetName.ToLower();
DpResultSet resultset = (DpResultSet)this.ResultSets[strResultSetName];
if (resultset == null)
{
if (bAutoCreate == false)
{
return(null);
}
#if NO
resultset = new DpResultSet();
resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
#endif
resultset = NewResultSet();
this.ResultSets[strResultSetName] = resultset;
}
return(resultset);
}
// 创建同时带节点和结果集的ReversePolishItem对象,并push到栈里
// parameter:
// node 节点
// oResult 结果集
// return:
// void
public void Push(XmlNode node,
DpResultSet oResult)
{
ReversePolishItem oItem = new ReversePolishItem(node,
oResult);
Add(oItem);
}
// parameters:
// bChangeVersion 是否修改版本号
// lNewVersion 返回修改后的新版本号。如果bChangeVersion==false, 此参数也返回没有发生过变化的版本号
// strContent 返回已经删除的记录的内容
int DeleteItem(DpResultSet resultset,
string strRefID,
bool bChangeVersion,
bool bAllowDeleteNotifyItem,
out long lNewVersion,
out string strContent,
out string strError)
{
strError = "";
lNewVersion = 0;
strContent = "";
for (long i = 0; i < resultset.Count; i++)
{
DpRecord record = resultset[i];
if (record.ID == strRefID)
{
strContent = record.BrowseText;
if (bAllowDeleteNotifyItem == false &&
string.IsNullOrEmpty(strContent) == false)
{
XmlDocument dom = new XmlDocument();
try
{
dom.LoadXml(strContent);
}
catch (Exception ex)
{
strError = "记录内容装入XMLDOM时出错: " + ex.Message;
return(-1);
}
string strClass = DomUtil.GetAttr(dom.DocumentElement, "class");
strClass.Replace(" ", ",");
if (StringUtil.IsInList("notify", strClass) == true)
{
strError = "notify事项不允许删除";
return(-1);
}
}
resultset.RemoveAt((int)i);
if (resultset == this.m_resultset)
{
if (bChangeVersion == true)
{
this.ContentFileVersion = DateTime.Now.Ticks; // 文件版本发生变化
}
lNewVersion = this.ContentFileVersion;
}
return(1); // deleted
}
}
strError = "refid为 '" + strRefID + "' 的事项没有找到";
return(0); // not found
}
void FlushTable(Hashtable temp_table, DpResultSet resultset)
{
foreach (string path in temp_table.Keys)
{
this._app_down.Token.ThrowIfCancellationRequested();
DpRecord record_bibliorecpath = new DpRecord(path);
resultset.Add(record_bibliorecpath);
}
}
// 创建一个新的结果集对象，但并不进入容器管理范畴
public DpResultSet NewResultSet()
{
DpResultSet resultset = new DpResultSet(GetTempFileName);
Debug.Assert(string.IsNullOrEmpty(this.app.ResultsetDir) == false, "");
resultset.TempFileDir = this.app.ResultsetDir;
// resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
return(resultset);
}
ChatInfo GetInfo(
DpResultSet resultset,
long nStart,
long nCount,
bool bDisplayAllIP)
{
ChatInfo info = new ChatInfo();
info.Name = this.Name;
long nMax = 0;
if (nCount == -1)
{
nMax = resultset.Count;
}
else
{
nMax = Math.Min(resultset.Count, nStart + nCount);
}
if (nMax - nStart > MAX_COUNT_PER_GET)
{
nMax = nStart + MAX_COUNT_PER_GET;
}
string strResult = "";
for (long i = nStart; i < nMax; i++)
{
DpRecord record = resultset[i];
if (bDisplayAllIP == true)
{
strResult += record.BrowseText;
}
else
{
strResult += MaskIP(record.BrowseText);
}
}
info.ResultText = strResult;
info.NextStart = nMax; // 结束位置
info.TotalLines = resultset.Count;
if (resultset == this.m_resultset)
{
info.ResultVersion = this.ContentFileVersion;
}
else
{
info.ResultVersion = 0; // 暂时无法给出
}
return(info);
}
// 记载一个全局结果集
// parameters:
// strName 全局结果集名字。如果为空，表示希望函数自动发生一个结果集名
// resultset 要设置的结果集对象。如果为null，表示想从全局结果集中清除这个名字的结果集对象。如果strName和resultset参数都为空，表示想清除全部全局结果集对象
// return:
// 返回实际设置的结果集名字
public string SetResultset(
string strName,
DpResultSet resultset)
{
if (this.m_lock.TryEnterWriteLock(this.m_nLockTimeout) == false)
{
throw new ApplicationException("为 全局结果集集合 加写锁时失败。Timeout=" + this.m_nLockTimeout.ToString());
}
try
{
if (string.IsNullOrEmpty(strName) == true)
{
if (resultset == null)
{
foreach (string key in this.Keys)
{
// 2016/1/23
resultset = (DpResultSet)this[key];
if (resultset != null)
{
resultset.GetTempFilename -= new GetTempFilenameEventHandler(resultset_GetTempFilename);
resultset.Close();
}
}
this.Clear();
return(null);
}
// 自动发生一个名字
strName = Guid.NewGuid().ToString();
}
if (resultset == null)
{
// 2016/1/23
resultset = (DpResultSet)this[strName];
if (resultset != null)
{
resultset.GetTempFilename -= new GetTempFilenameEventHandler(resultset_GetTempFilename);
resultset.Close();
}
this.Remove(strName);
return(strName);
}
FreeResultSet(strName);
resultset.Touch();
this[strName] = resultset;
return(strName);
}
finally
{
this.m_lock.ExitWriteLock();
}
}
// TODO: 似乎锁定不太严密。可以改用 UpgradeableReadLock
// TODO: 全局结果集的名字可否就是文件名? 这样如果需要永久保持，下次启动的时候从文件系统就能列举出结果集名字
public DpResultSet GetResultSet(string strResultSetName,
bool bAutoCreate = true)
{
if (String.IsNullOrEmpty(strResultSetName) == true)
{
// strResultSetName = "default";
throw new ArgumentException("结果集名不应为空");
}
strResultSetName = strResultSetName.ToLower();
DpResultSet resultset = null;
if (this.m_lock.TryEnterReadLock(this.m_nLockTimeout) == false)
{
throw new ApplicationException("为 全局结果集集合 加读锁时失败。Timeout=" + this.m_nLockTimeout.ToString());
}
try
{
resultset = (DpResultSet)this[strResultSetName];
}
finally
{
this.m_lock.ExitReadLock();
}
if (resultset == null)
{
if (bAutoCreate == false)
{
return(null);
}
resultset = new DpResultSet(GetTempFileName);
// 注：这里要特别注意在 resultset 对象销毁以前卸载事件
resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
if (this.m_lock.TryEnterWriteLock(this.m_nLockTimeout) == false)
{
throw new ApplicationException("为 全局结果集集合 加写锁时失败。Timeout=" + this.m_nLockTimeout.ToString());
}
try
{
this[strResultSetName] = resultset;
}
finally
{
this.m_lock.ExitWriteLock();
}
}
resultset.Touch();
return(resultset);
}
// 注意，没有锁定集合
void FreeResultSet(string strOldName)
{
DpResultSet resultset = (DpResultSet)this[strOldName];
if (resultset == null)
{
return;
}
this.Remove(strOldName);
resultset.Close();
}
public void Close()
{
if (this.m_resultset != null)
{
string strTemp1 = "";
string strTemp2 = "";
m_resultset.Detach(out strTemp1,
out strTemp2);
this.m_resultset = null;
}
this.ContentFileName = "";
}
int PrepareContentFileName(out string strError)
{
strError = "";
Debug.Assert(string.IsNullOrEmpty(this.DataDirectory) == false, "");
string strDate = DateTimeUtil.DateTimeToString8(DateTime.Now);
string strFileName = PathUtil.MergePath(DataDirectory, strDate);
if (this.ContentFileName != strFileName)
{
this.Close();
this.ContentFileName = strFileName;
try
{
m_resultset = new DpResultSet(false, false);
// 如果文件存在，就打开，如果文件不存在，就创建一个新的
if (File.Exists(this.ContentFileName) == true)
{
m_resultset.Attach(this.ContentFileName,
this.ContentFileName + ".index");
}
else
{
m_resultset.Create(this.ContentFileName,
this.ContentFileName + ".index");
}
this.ContentFileVersion = DateTime.Now.Ticks;
this.Date = strDate;
}
catch (Exception ex)
{
strError = "打开或创建结果集文件 '" + this.ContentFileName + "' (和.index) 发生错误: " + ex.Message;
this.ContentFileName = "";
return(-1);
}
}
else
{
Debug.Assert(m_resultset != null, "");
}
return(0);
}
public DpResultSet GetResultSet(string strResultSetName,
bool bAutoCreate = true)
{
if (String.IsNullOrEmpty(strResultSetName) == true)
{
// strResultSetName = "default";
throw new Exception("结果集名不应为空");
}
strResultSetName = strResultSetName.ToLower();
DpResultSet resultset = null;
if (this.m_lock.TryEnterReadLock(this.m_nLockTimeout) == false)
throw new ApplicationException("为 全局结果集集合 加读锁时失败。Timeout=" + this.m_nLockTimeout.ToString());
try
{
resultset = (DpResultSet)this[strResultSetName];
}
finally
{
this.m_lock.ExitReadLock();
}
if (resultset == null)
{
if (bAutoCreate == false)
return null;
resultset = new DpResultSet(GetTempFileName);
resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
if (this.m_lock.TryEnterWriteLock(this.m_nLockTimeout) == false)
throw new ApplicationException("为 全局结果集集合 加写锁时失败。Timeout=" + this.m_nLockTimeout.ToString());
try
{
this[strResultSetName] = resultset;
}
finally
{
this.m_lock.ExitWriteLock();
}
}
resultset.Touch();
return resultset;
}
// 获取指纹信息，追加到结果集文件的尾部
// parameters:
// update_table key为读者记录路径
void AppendFingerprintInfo(
LibraryChannel channel,
DpResultSet resultset,
Hashtable update_table,
CancellationToken token)
{
List <string> lines = new List <string>();
foreach (string recpath in update_table.Keys)
{
lines.Add(recpath);
}
BrowseLoader loader = new BrowseLoader();
loader.RecPaths = lines;
loader.Channel = channel;
loader.Format = $"id,cols,format:cfgs/browse_{this.BrowseStyle}";
loader.Prompt += this.Loader_Prompt;
foreach (DigitalPlatform.LibraryClient.localhost.Record record in loader)
{
token.ThrowIfCancellationRequested();
this.ShowMessage("追加 " + record.Path);
if (record.Cols == null || record.Cols.Length < 3)
{
string strError = $"record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_{this.BrowseStyle}";
// TODO: 并发操作的情况下，会在中途出现读者记录被别的前端修改的情况，这里似乎可以continue
throw new Exception(strError);
}
// 如果证条码号为空，无法建立对照关系，要跳过
if (string.IsNullOrEmpty(record.Cols[1]) == true)
{
continue;
}
DpRecord item = new DpRecord(record.Path);
// timestamp | barcode | fingerprint
item.BrowseText = record.Cols[0] + "|" + record.Cols[1] + "|" + record.Cols[2];
resultset.Add(item);
}
}
public DpResultSet m_resultSet; // 结果集
// 构造函数
// parameter:
// node 节点
// oResultSet 结果集
public ReversePolishItem(XmlNode node,
DpResultSet resultSet)
{
m_node = node;
m_resultSet = resultSet;
if (m_node != null)
{
m_int = 0; //0表示XmlNode
}
else if (m_resultSet != null)
{
m_int = 1; //1表示resultSet
}
else
{
m_int = -1;
}
}
public void ClearResultSets()
{
foreach (string key in this.ResultSets.Keys)
{
DpResultSet resultset = (DpResultSet)this.ResultSets[key];
if (resultset != null)
{
try
{
resultset.Close();
}
catch
{
}
}
}
this.ResultSets.Clear();
}
public bool RenameResultSet(string strOldName, string strNewName)
{
if (String.IsNullOrEmpty(strOldName) == true)
{
throw new ArgumentException("结果集名不应为空", "strOldName");
}
if (String.IsNullOrEmpty(strNewName) == true)
{
throw new ArgumentException("结果集名不应为空", "strNewName");
}
strOldName = strOldName.ToLower();
strNewName = strNewName.ToLower();
if (strOldName == strNewName)
{
throw new ArgumentException("strOldName 和 strNewName 参数值不应相同");
}
if (this.m_lock.TryEnterWriteLock(this.m_nLockTimeout) == false)
{
throw new ApplicationException("为 全局结果集集合 加写锁时失败。Timeout=" + this.m_nLockTimeout.ToString());
}
try
{
DpResultSet resultset = (DpResultSet)this[strOldName];
if (resultset == null)
{
return(false);
}
// 如果新名字存在，则要释放已有对象
FreeResultSet(strNewName);
this[strNewName] = resultset;
this.Remove(strOldName);
return(true);
}
finally
{
this.m_lock.ExitWriteLock();
}
}
// 将内存数组写入结果集文件
public static int WriteToResulsetFile(
KeyValueCollection items,
string strResultsetFilename,
out string strError)
{
strError = "";
DpResultSet resultset = new DpResultSet(false, false);
resultset.Create(strResultsetFilename,
strResultsetFilename + ".index");
bool bDone = false;
try
{
foreach (KeyValue item in items)
{
DpRecord record = new DpRecord(item.Value);
record.BrowseText = item.Key;
resultset.Add(record);
}
bDone = true;
return(0);
}
finally
{
if (bDone == true)
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1,
out strTemp2);
}
else
{
// 否则文件会被删除
resultset.Close();
}
}
}
// 把结果集归入容器管理
// parameters:
// resultset 结果集对象。如果为 null，实际上效果是删除这个结果集条目
public void SetResultSet1(string strResultSetName,
DpResultSet resultset)
{
if (String.IsNullOrEmpty(strResultSetName) == true)
{
strResultSetName = "default";
}
strResultSetName = strResultSetName.ToLower();
DpResultSet exist_resultset = (DpResultSet)this.ResultSets[strResultSetName];
// 即将设置的结果集正好是已经存在的结果集
if (exist_resultset == resultset)
{
return; // exist_resultset;
}
if (resultset == null)
{
this.ResultSets.Remove(strResultSetName);
}
else
{
this.ResultSets[strResultSetName] = resultset;
}
/*
* resultset.GetTempFilename -= new GetTempFilenameEventHandler(resultset_GetTempFilename);
* resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
* */
if (exist_resultset != null)
{
// 释放以前的同名结果集对象
exist_resultset.Close();
}
return; // exist_resultset;
}
// 从结果集中提取指定范围的记录
// parameter:
// strRanges 范围
// strStyle 样式,以逗号分隔，id:表示取id,cols表示取浏览格式,xml表示取xml记录体
// strLang 语言版本，用来获得记录路径
// richRecords 得到的记录数组，成员为类型为Record
// result:
// -1 出错
// >=0 结果集的总数
public long API_GetRichRecords(
DpResultSet resultset,
string strRanges,
string strLang,
string strStyle,
out RichRecord[] richRecords,
out string strError)
{
strError = "";
richRecords = null;
int nCurCount = 0;
List<RichRecord> aRichRecord = new List<RichRecord>();
string strFormat = StringUtil.GetStyleParam(strStyle, "format");
RangeList rangeList = new RangeList(strRanges);
for (int i = 0; i < rangeList.Count; i++)
{
RangeItem rangeItem = (RangeItem)rangeList[i];
int nStart = (int)rangeItem.lStart;
int nLength = (int)rangeItem.lLength;
if (nLength == 0)
continue;
// long lPos = 0; // 应该用快速方式，不应用[]??? 2006/3/29
for (int j = 0; j < nLength; j++)
{
int nRet = 0;
DpRecord dpRecord = resultset[j + nStart];
RichRecord richRecord = new RichRecord();
DbPath dbpath = new DbPath(dpRecord.ID);
Database db = this.app.Dbs.GetDatabaseSafety(dbpath.Name);
if (db == null) //也应放到本条的记录出错信息里
{
strError = "没有找到数据库'" + dbpath.Name + "'，换语言版本时出错";
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = KernelApplication.Ret2ErrorCode(nRet);
richRecord.Result.ErrorString = strError;
}
else
{
// 记录路径
if (StringUtil.IsInList("id", strStyle, true) == true
|| StringUtil.IsInList("path", strStyle, true) == true)
{
richRecord.Path = db.GetCaptionSafety(strLang) + "/" + dbpath.CompressedID;
}
// 浏览列
if (StringUtil.IsInList("cols", strStyle, true) == true)
{
string[] cols = null;
/*未完成
nRet = db.GetCols(dbpath.ID10,
out cols,
out strError);
if (nRet <= -1)
{
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = GlobalInfo.Ret2ErrorCode(nRet);
richRecord.Result.ErrorString = strError;
}
*/
nRet = db.GetCols(
strFormat,
dbpath.ID10,
"",
0,
out cols);
// 2013/1/14
if (nRet == -1)
{
if (cols != null && cols.Length > 0)
strError = cols[0];
else
strError = "GetCols() error";
return -1;
}
richRecord.Cols = cols;
}
bool bXml = false;
bool bTimestamp = false;
if (StringUtil.IsInList("xml", strStyle, true) == true)
bXml = true;
if (StringUtil.IsInList("timestamp", strStyle, true) == true)
bTimestamp = true;
if (bXml == true
|| bTimestamp == true)
{
string strGetStyle = ""; //"data,timestamp"; // ,outputpath, metadata
if (bTimestamp == true)
StringUtil.SetInList(ref strGetStyle, "timestamp", true);
if (bXml == true)
StringUtil.SetInList(ref strGetStyle, "data", true);
int nStart0 = 0;
int nLength0 = -1;
int nMaxLength = 300 * 1024; // 每次最多获取300K
int nTotalLength = 0;
string strOutputID = "";
byte[] baTotal = null;
byte[] baOutputTimestamp = null;
int nAdditionError = 0;
string strMetadata = "";
for (; ; )
{
byte[] baData = null;
long lRet = db.GetXml(dbpath.ID,
"", // strXPath,
nStart0,
nLength0,
nMaxLength,
strGetStyle,
out baData,
out strMetadata,
out strOutputID,
out baOutputTimestamp,
true,
out nAdditionError,
out strError);
if (lRet <= -1)
{
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = KernelApplication.Ret2ErrorCode(nAdditionError); // nRet?
richRecord.Result.ErrorString = strError;
goto CONTINUE;
}
nTotalLength = (int)lRet;
// 如果数据体太大
if (nTotalLength > QUOTA_SIZE)
{
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = ErrorCodeValue.CommonError;
richRecord.Result.ErrorString = "数据超过1M";
goto CONTINUE;
}
baTotal = ByteArray.Add(baTotal, baData);
nStart0 += baData.Length;
if (nStart0 >= nTotalLength)
break;
}
// 记录体
// 转换成字符串
if (StringUtil.IsInList("xml", strStyle, true) == true)
{
richRecord.Xml = ByteArray.ToString(baTotal);
}
// 时间戳?
if (StringUtil.IsInList("timestamp", strStyle, true) == true)
{
richRecord.baTimestamp = baOutputTimestamp;
}
// string strOutputPath = strDbName + "/" + strOutputID;
}
// 记录体
if (StringUtil.IsInList("xml", strStyle, true) == true)
{
/*
nRet = db.GetXmlDataSafety(dbpath.ID,
out richRecord.Xml,
out strError);
if (nRet <= -1)
{
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = RmswsApplication.Ret2ErrorCode(nRet);
richRecord.Result.ErrorString = strError;
}
* */
}
}
CONTINUE:
aRichRecord.Add(richRecord);
Thread.Sleep(0);
nCurCount++;
// 如果超出最大范围，则停止
if (nCurCount >= SessionInfo.MaxRecordsCountPerApi)
break;
}
}
richRecords = new RichRecord[aRichRecord.Count];
for (int i = 0; i < richRecords.Length; i++)
{
richRecords[i] = aRichRecord[i];
}
return resultset.Count;
}
// 把结果集归入容器管理
public void SetResultSet1(string strResultSetName,
DpResultSet resultset)
{
if (String.IsNullOrEmpty(strResultSetName) == true)
strResultSetName = "default";
strResultSetName = strResultSetName.ToLower();
DpResultSet exist_resultset = (DpResultSet)this.ResultSets[strResultSetName];
// 即将设置的结果集正好是已经存在的结果集
if (exist_resultset == resultset)
return; // exist_resultset;
this.ResultSets[strResultSetName] = resultset;
/*
resultset.GetTempFilename -= new GetTempFilenameEventHandler(resultset_GetTempFilename);
resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
* */
if (exist_resultset != null)
{
// 释放以前的同名结果集对象
exist_resultset.Close();
}
return; // exist_resultset;
}
public DpResultSet GetResultSet(string strResultSetName,
bool bAutoCreate = true)
{
if (String.IsNullOrEmpty(strResultSetName) == true)
strResultSetName = "default";
strResultSetName = strResultSetName.ToLower();
DpResultSet resultset = (DpResultSet)this.ResultSets[strResultSetName];
if (resultset == null)
{
if (bAutoCreate == false)
return null;
#if NO
resultset = new DpResultSet();
resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
#endif
resultset = NewResultSet();
this.ResultSets[strResultSetName] = resultset;
}
return resultset;
}
// 初始化一个读者库的指纹缓存
// return:
// -1 出错
// >=0 实际发送给接口程序的事项数目
static int BuildOneDbCache(
LibraryChannel channel,
string strDir,
string strReaderDbName,
CancellationToken token,
out string strError)
{
strError = "";
int nRet = 0;
DpResultSet resultset = null;
bool bCreate = false;
Hashtable timestamp_table = new Hashtable(); // recpath --> fingerprint timestamp
ShowMessage(strReaderDbName);
// 结果集文件名
string strResultsetFilename = Path.Combine(strDir, strReaderDbName);
if (File.Exists(strResultsetFilename) == false)
{
resultset = new DpResultSet(false, false);
resultset.Create(strResultsetFilename,
strResultsetFilename + ".index");
bCreate = true;
}
else
{
bCreate = false;
}
// *** 第一阶段， 创建新的结果集文件；或者获取全部读者记录中的指纹时间戳
bool bDone = false; // 创建情形下 是否完成了写入操作
try
{
/*
* long lRet = Channel.SearchReader(stop,
* strReaderDbName,
* "1-9999999999",
* -1,
* "__id",
* "left",
* this.Lang,
* null, // strResultSetName
* "", // strOutputStyle
* out strError);
*/
long lRet = channel.SearchReader(null, // stop,
strReaderDbName,
"",
-1,
"指纹时间戳",
"left",
ClientInfo.Lang,
null, // strResultSetName
"", // strOutputStyle
out strError);
if (lRet == -1)
{
if (channel.ErrorCode == ErrorCode.AccessDenied)
{
strError = "用户 " + channel.UserName + " 权限不足: " + strError;
}
return(-1);
}
if (lRet == 0)
{
// TODO: 这时候如果以前有结果集文件还会残留，但不会影响功能正确性，可以改进为把残留的结果集文件删除
return(0);
}
long lHitCount = lRet;
ResultSetLoader loader = new ResultSetLoader(channel,
null,
null,
bCreate == true ? "id,cols,format:cfgs/browse_fingerprint" : "id,cols,format:cfgs/browse_fingerprinttimestamp",
ClientInfo.Lang);
loader.Prompt += Loader_Prompt;
foreach (DigitalPlatform.LibraryClient.localhost.Record record in loader)
{
token.ThrowIfCancellationRequested();
ShowMessage("正在处理读者记录 " + record.Path);
if (bCreate == true)
{
if (record.Cols == null || record.Cols.Length < 3)
{
strError = "record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_fingerprint";
return(-1);
}
if (string.IsNullOrEmpty(record.Cols[0]) == true)
{
continue; // 读者记录中没有指纹信息
}
DpRecord item = new DpRecord(record.Path);
// timestamp | barcode | fingerprint
item.BrowseText = record.Cols[0] + "|" + record.Cols[1] + "|" + record.Cols[2];
resultset.Add(item);
}
else
{
if (record.Cols == null || record.Cols.Length < 1)
{
strError = "record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_fingerprinttimestamp";
return(-1);
}
if (record.Cols.Length < 2)
{
strError = "record.Cols error ... 需要刷新配置文件 cfgs/browse_fingerprinttimestamp 到最新版本";
return(-1);
}
if (string.IsNullOrEmpty(record.Cols[0]) == true)
{
continue; // 读者记录中没有指纹信息
}
// 记载时间戳
// timestamp | barcode
timestamp_table[record.Path] = record.Cols[0] + "|" + record.Cols[1];
}
}
#if NO
// stop.SetProgressRange(0, lHitCount);
long lStart = 0;
long lCount = lHitCount;
DigitalPlatform.LibraryClient.localhost.Record[] searchresults = null;
// 装入浏览格式
for (; ;)
{
token.ThrowIfCancellationRequested();
lRet = channel.GetSearchResult(
null,
null, // strResultSetName
lStart,
lCount,
bCreate == true ? "id,cols,format:cfgs/browse_fingerprint" : "id,cols,format:cfgs/browse_fingerprinttimestamp",
ClientInfo.Lang,
out searchresults,
out strError);
if (lRet == -1)
{
return(-1);
}
if (lRet == 0)
{
strError = "GetSearchResult() return 0";
return(-1);
}
Debug.Assert(searchresults != null, "");
Debug.Assert(searchresults.Length > 0, "");
for (int i = 0; i < searchresults.Length; i++)
{
DigitalPlatform.LibraryClient.localhost.Record record = searchresults[i];
if (bCreate == true)
{
if (record.Cols == null || record.Cols.Length < 3)
{
strError = "record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_fingerprint";
return(-1);
}
if (string.IsNullOrEmpty(record.Cols[0]) == true)
{
continue; // 读者记录中没有指纹信息
}
DpRecord item = new DpRecord(record.Path);
// timestamp | barcode | fingerprint
item.BrowseText = record.Cols[0] + "|" + record.Cols[1] + "|" + record.Cols[2];
resultset.Add(item);
}
else
{
if (record.Cols == null || record.Cols.Length < 1)
{
strError = "record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_fingerprinttimestamp";
return(-1);
}
if (record.Cols.Length < 2)
{
strError = "record.Cols error ... 需要刷新配置文件 cfgs/browse_fingerprinttimestamp 到最新版本";
return(-1);
}
if (string.IsNullOrEmpty(record.Cols[0]) == true)
{
continue; // 读者记录中没有指纹信息
}
// 记载时间戳
// timestamp | barcode
timestamp_table[record.Path] = record.Cols[0] + "|" + record.Cols[1];
}
}
lStart += searchresults.Length;
lCount -= searchresults.Length;
//stop.SetMessage(strReaderDbName + " 包含记录 " + lHitCount.ToString() + " 条，已装入 " + lStart.ToString() + " 条");
if (lStart >= lHitCount || lCount <= 0)
{
break;
}
//stop.SetProgressValue(lStart);
}
#endif
if (bCreate == true)
{
bDone = true;
}
if (bCreate == true)
{
// return:
// -2 remoting服务器连接失败。驱动程序尚未启动
// -1 出错
// >=0 实际发送给接口程序的事项数目
nRet = CreateFingerprintCache(resultset,
out strError);
if (nRet == -1 || nRet == -2)
{
return(-1);
}
return(nRet);
}
}
finally
{
if (bCreate == true)
{
Debug.Assert(resultset != null, "");
if (bDone == true)
{
resultset.Detach(out string strTemp1,
out string strTemp2);
}
else
{
// 否则文件会被删除
resultset.Close();
}
}
}
// 比对时间戳，更新结果集文件
Hashtable update_table = new Hashtable(); // 需要更新的事项。recpath --> 1
resultset = new DpResultSet(false, false);
resultset.Attach(strResultsetFilename,
strResultsetFilename + ".index");
try
{
long nCount = resultset.Count;
for (long i = 0; i < nCount; i++)
{
token.ThrowIfCancellationRequested();
DpRecord record = resultset[i];
string strRecPath = record.ID;
ShowMessage("比对 " + strRecPath);
// timestamp | barcode
string strNewTimestamp = (string)timestamp_table[strRecPath];
if (strNewTimestamp == null)
{
// 最新状态下，读者记录已经不存在，需要从结果集中删除
resultset.RemoveAt((int)i);
i--;
nCount--;
continue;
}
// 拆分出证条码号 2013/1/28
string strNewBarcode = "";
nRet = strNewTimestamp.IndexOf("|");
if (nRet != -1)
{
strNewBarcode = strNewTimestamp.Substring(nRet + 1);
strNewTimestamp = strNewTimestamp.Substring(0, nRet);
}
// 最新读者记录中已经没有指纹信息。例如读者记录中的指纹元素被删除了
if (string.IsNullOrEmpty(strNewTimestamp) == true)
{
// 删除现有事项
resultset.RemoveAt((int)i);
i--;
nCount--;
timestamp_table.Remove(strRecPath);
continue;
}
// 取得结果集文件中的原有时间戳字符串
string strText = record.BrowseText; // timestamp | barcode | fingerprint
nRet = strText.IndexOf("|");
if (nRet == -1)
{
strError = "browsetext 错误，没有 '|' 字符";
return(-1);
}
string strOldTimestamp = strText.Substring(0, nRet);
// timestamp | barcode | fingerprint
string strOldBarcode = strText.Substring(nRet + 1);
nRet = strOldBarcode.IndexOf("|");
if (nRet != -1)
{
strOldBarcode = strOldBarcode.Substring(0, nRet);
}
// 时间戳发生变化，需要更新事项
if (strNewTimestamp != strOldTimestamp ||
strNewBarcode != strOldBarcode)
{
// 如果证条码号为空，无法建立对照关系，要跳过
if (string.IsNullOrEmpty(strNewBarcode) == false)
{
update_table[strRecPath] = 1;
}
// 删除现有事项
resultset.RemoveAt((int)i);
i--;
nCount--;
}
timestamp_table.Remove(strRecPath);
}
// 循环结束后，timestamp_table中剩余的是当前结果集文件中没有包含的那些读者记录路径
if (update_table.Count > 0)
{
// 获取指纹信息，追加到结果集文件的尾部
// parameters:
// update_table key为读者记录路径
AppendFingerprintInfo(
channel,
resultset,
update_table,
token);
}
// 如果服务器端新增了指纹信息,需要获取后追加到结果集文件尾部
if (timestamp_table.Count > 0)
{
// 获取指纹信息，追加到结果集文件的尾部
// parameters:
// update_table key为读者记录路径
AppendFingerprintInfo(
channel,
resultset,
timestamp_table,
token);
}
// return:
// -2 remoting服务器连接失败。驱动程序尚未启动
// -1 出错
// >=0 实际发送给接口程序的事项数目
nRet = CreateFingerprintCache(resultset,
out strError);
if (nRet == -1 || nRet == -2)
{
return(-1);
}
return(nRet);
}
finally
{
resultset.Detach(out string strTemp1, out string strTemp2);
}
}
// 递归函数，得一个节点的集合，外面doSearch调该函数
// parameter:
// nodeRoot 当前根节点
// oResult 结果集
// return:
// -1 出错
// -6 无权限
// 0 成功
public int DoQuery(XmlNode nodeRoot,
DpResultSet resultSet,
Delegate_isConnected isConnected,
out string strError)
{
strError = "";
if (nodeRoot == null)
{
strError = "DoQuery() nodeRoot参数不能为null。";
return(-1);
}
if (resultSet == null)
{
strError = "DoQuery() resultSet参数不能为null。";
return(-1);
}
//先清空一下
resultSet.Clear();
//到item时不再继续递归
if (nodeRoot.Name == "item")
{
// return:
// -1 出错
// -6 无足够的权限
// 0 成功
return(doItem(nodeRoot,
resultSet,
isConnected,
out strError));
}
//如果为扩展节点，则不递归
if (nodeRoot.Name == "operator" ||
nodeRoot.Name == "lang")
{
return(0);
}
//将正常顺利变成逆波兰表序
ArrayList rpn;
int nRet = Infix2RPN(nodeRoot,
out rpn,
out strError);
if (nRet == -1)
{
strError = "逆波兰表错误:" + strError;
return(-1);
}
//属于正常情况
if (rpn.Count == 0)
{
return(0);
}
// return:
// -1 出错
// -6 无足够的权限
// 0 成功
nRet = ProceedRPN(rpn,
resultSet,
isConnected,
out strError);
if (nRet <= -1)
{
return(nRet);
}
return(0);
}
// return:
// fasle 正常完成
// true 中断
static bool DoSort(DpResultSet resultset,
ChannelHandle handle
// Delegate_isConnected isConnected
)
{
resultset.Idle += new IdleEventHandler(sort_Idle);
resultset.Param = handle; // isConnected;
try
{
resultset.Sort();
}
catch (InterruptException /*ex*/)
{
return true; // 中断
}
finally
{
resultset.Idle -= new IdleEventHandler(sort_Idle);
resultset.Param = null;
}
return false;
}
static void FlushTable(Hashtable temp_table, DpResultSet resultset)
{
foreach (string path in temp_table.Keys)
{
DpRecord record_bibliorecpath = new DpRecord(path);
resultset.Add(record_bibliorecpath);
}
}
// 从 dp2Library(其实也可以说dp2Kernel) 端获取结果集
// parameters:
// strStyle tobibliorecpath 将实体\期\订购\评注 记录路径转换为书目记录路径,并去重
int GetResultset(LibraryChannel channel,
string strResultsetName,
string strResultsetFilename,
string strStyle,
out int nCount,
out string strError)
{
strError = "";
nCount = 0;
long lStart = 0;
long lRet = 0;
m_biblioDbNameTable.Clear();
bool bToBiblioRecPath = StringUtil.IsInList("tobibliorecpath", strStyle);
#if NO
DpResultSet item_paths = null;
if (bToBiblioRecPath == true)
item_paths = new DpResultSet(true); // 临时文件会自动丢弃
#endif
DpResultSet resultset = new DpResultSet(false, false);
resultset.Create(strResultsetFilename,
strResultsetFilename + ".index");
bool bDone = false;
try
{
Hashtable temp_table = new Hashtable();
for (; ; )
{
if (this.m_bClosed == true || this.Stopped == true)
{
strError = "中断";
return -1;
}
Thread.Sleep(1);
// List<string> aPath = null;
Record[] searchresults = null;
string strGetStyle = "id";
if (bToBiblioRecPath == true)
strGetStyle = "id,cols,format:@coldef://parent"; // "id,xml";
lRet = channel.GetSearchResult(
null,
strResultsetName,
lStart,
-1, // 100
strGetStyle,
"zh",
out searchresults,
out strError);
if (lRet == -1)
return -1;
long lHitCount = lRet;
for (int j = 0; j < searchresults.Length; j++)
{
if ((j % 10) == 9)
this.SetProgressText("从检索结果中获得记录路径 " + (lStart + j + 1).ToString() + " 条");
Record rec = searchresults[j];
if (bToBiblioRecPath == false)
{
DpRecord record = new DpRecord(rec.Path);
resultset.Add(record);
}
else
{
if (rec.RecordBody != null
&& rec.RecordBody.Result != null
&& rec.RecordBody.Result.ErrorCode != ErrorCodeValue.NoError)
{
strError = "获得结果集位置偏移 " + (lStart + j).ToString() + " 时出错，该记录已被忽略: " + rec.RecordBody.Result.ErrorString;
this.AppendResultText(strError + "\r\n");
continue;
}
string strBiblioRecPath = "";
#if NO
// 从册记录XML中获得书目记录路径
// return:
// -1 出错
// 1 成功
int nRet = GetBiblioRecPath(
rec.Path,
rec.RecordBody.Xml,
out strBiblioRecPath,
out strError);
if (nRet == -1)
return -1;
#endif
if (rec.Cols == null || rec.Cols.Length == 0)
{
strError = "获得结果集位置偏移 " + (lStart + j).ToString() + " 时出错： rec.Cols 为空";
this.AppendResultText(strError + "\r\n");
continue;
}
// return:
// -1 出错
// 1 成功
int nRet = GetBiblioRecPathByParentID(
rec.Path,
rec.Cols[0],
out strBiblioRecPath,
out strError);
if (nRet == -1)
return -1;
// 缓冲并局部去重
if (temp_table.Contains(strBiblioRecPath) == false)
{
temp_table.Add(strBiblioRecPath, null);
if (temp_table.Count > 1000)
{
FlushTable(temp_table, resultset);
temp_table.Clear();
}
}
//DpRecord record = new DpRecord(rec.Path);
//item_paths.Add(record);
}
}
if (searchresults.Length <= 0 // < 100
)
break;
lStart += searchresults.Length;
nCount += searchresults.Length;
if (lStart >= lHitCount)
break;
}
if (bToBiblioRecPath == true)
{
#if NO
Hashtable temp_table = new Hashtable();
for (int j = 0; j < item_paths.Count; j++)
{
// Debug.WriteLine("output " + j.ToString());
DpRecord record = item_paths[j];
string strPath = record.ID;
Record rec = searchresults[j];
XmlDocument itemdom = null;
int nRet = OpacApplication.LoadToDom(rec.RecordBody.Xml,
out itemdom,
out strError);
if (nRet == -1)
{
strError = "装载记录 '" + strPath + "' 进入XML DOM时发生错误: " + strError;
return -1;
}
string strBiblioDbName = "";
string strDbName = ResPath.GetDbName(strPath);
string strDbType = this.App.GetDbType(strDbName,
out strBiblioDbName);
if (strDbType == null)
{
strError = "数据库 '" + strDbName + "' 的类型无法识别";
return -1;
}
string strParentID = DomUtil.GetElementText(itemdom.DocumentElement,
"parent");
string strBiblioRecPath = strBiblioDbName + "/" + strParentID;
// 缓冲并局部去重
if (temp_table.Contains(strBiblioRecPath) == false)
{
temp_table.Add(strBiblioRecPath, null);
if (temp_table.Count > 1000)
{
FlushTable(temp_table, resultset);
temp_table.Clear();
}
}
if ((j % 10) == 9)
this.SetProgressText("已转换写入书目记录路径 " + (j + 1).ToString() + " 条");
if ((j % 1000) == 999)
this.AppendResultText("已转换写入书目记录路径 "+(j+1).ToString()+" 条" + "\r\n");
/*
DpRecord record_bibliorecpath = new DpRecord(strBiblioRecPath);
resultset.Add(record_bibliorecpath);
* */
}
#endif
if (temp_table.Count > 0)
{
FlushTable(temp_table, resultset);
temp_table.Clear();
}
// 归并后写入结果集文件
resultset.Idle += new IdleEventHandler(biblio_paths_Idle); // 2016/1/23 原来这里是 -=，令人费解
try
{
this.SetProgressText("正在排序");
this.AppendResultText("开始排序。事项数 " + resultset.Count + "\r\n");
resultset.QuickSort();
this.AppendResultText("结束排序。事项数 " + resultset.Count + "\r\n");
this.SetProgressText("正在去重");
resultset.Sorted = true; // 2012/5/30
this.AppendResultText("开始去重。事项数 " + resultset.Count + "\r\n");
resultset.RemoveDup();
this.AppendResultText("结束去重。事项数 " + resultset.Count + "\r\n");
}
catch (InterruptException /*ex*/)
{
strError = "中断";
return -1;
}
finally
{
resultset.Idle -= new IdleEventHandler(biblio_paths_Idle);
}
}
this.SetProgressText("输出结果集完成");
bDone = true;
}
finally
{
if (bDone == true)
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1,
out strTemp2);
}
else
{
// 否则文件会被删除
resultset.Close();
}
}
return 0;
}
// 外部调用
public static int AddToResultset(List<string> aPath,
string strResultsetFilename,
bool bInsertAtFirst,
out string strError)
{
strError = "";
DpResultSet resultset = null;
bool bCreate = false;
try
{
if (File.Exists(strResultsetFilename) == true)
{
resultset = new DpResultSet(false, false);
resultset.Attach(strResultsetFilename,
strResultsetFilename + ".index");
}
else
{
bCreate = true;
resultset = new DpResultSet(false, false);
resultset.Create(strResultsetFilename,
strResultsetFilename + ".index");
}
}
catch (Exception ex)
{
strError = (bCreate == true ? "创建" : "打开")
+ "结果集(文件为'" + strResultsetFilename + "')发生错误: " + ex.Message;
return -1;
}
bool bDone = false;
try
{
for (int j = 0; j < aPath.Count; j++)
{
Thread.Sleep(1);
DpRecord record = new DpRecord(aPath[j]);
if (bInsertAtFirst == true)
resultset.Insert(0, record);
else
resultset.Add(record);
}
bDone = true;
}
finally
{
if (bDone == true || bCreate == false)
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1,
out strTemp2);
}
else
{
// 否则文件会被删除
resultset.Close();
}
}
return 0;
}
// 外部调用
public static int RemoveFromResultset(List<string> aPath,
string strResultsetFilename,
out string strError)
{
strError = "";
if (File.Exists(strResultsetFilename) == false)
{
strError = "结果集文件 '" + strResultsetFilename + "' 不存在";
return -1;
}
DpResultSet resultset = null;
try
{
resultset = new DpResultSet(false, false);
resultset.Attach(strResultsetFilename,
strResultsetFilename + ".index");
}
catch (Exception ex)
{
strError = "打开结果集(文件为'" + strResultsetFilename + "')发生错误: " + ex.Message;
return -1;
}
try
{
for (int i = 0; i < resultset.Count; i++)
{
DpRecord record = resultset[i];
int index = aPath.IndexOf(record.ID);
if (index != -1)
{
resultset.RemoveAt(i);
i--;
}
}
}
finally
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1,
out strTemp2);
}
return 0;
}
// 删除一个事项
// 只是索引压缩了,数据文件没有处理。注意,也并没有删除事项所关联的图像文件
// 多线程：安全
// parameters:
// bChangeVersion 是否修改版本号
// lNewVersion 返回修改后的新版本号。如果bChangeVersion==false, 此参数也返回没有发生过变化的版本号
// strContent 返回已经删除的记录的内容
// return:
// -1 出错
// 0 没有找到
// 1 已经删除
public int DeleteItem(string strRefID,
string strDate,
bool bChangeVersion,
out long lNewVersion,
out string strContent,
out string strError)
{
strError = "";
lNewVersion = 0;
strContent = "";
if (strDate != this.Date)
{
// 要获得不是当天的内容
string strFileName = PathUtil.MergePath(DataDirectory, strDate);
if (File.Exists(strFileName) == false)
{
strError = "日期为 '" + strDate + "' 的文件不存在";
return(0);
}
int nRet = 0;
DpResultSet resultset = new DpResultSet(false, false);
resultset.Attach(strFileName,
strFileName + ".index");
try
{
nRet = DeleteItem(resultset,
strRefID,
bChangeVersion,
false,
out lNewVersion,
out strContent,
out strError);
}
finally
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1,
out strTemp2);
}
FileInfo fi = new FileInfo(strFileName);
lNewVersion = fi.LastWriteTimeUtc.Ticks;
return(nRet);
}
else
{
m_lock.EnterReadLock();
try
{
// 打开当天的内容文件
int nRet = PrepareContentFileName(out strError);
if (nRet == -1)
{
return(-1);
}
return(DeleteItem(this.m_resultset,
strRefID,
bChangeVersion,
false,
out lNewVersion,
out strContent,
out strError));
}
finally
{
m_lock.ExitReadLock();
}
}
#if NO
/////
m_lock.EnterWriteLock();
try
{
// 打开当天的内容文件
int nRet = PrepareContentFileName(out strError);
if (nRet == -1)
{
return(-1);
}
return(DeleteItem(this.m_resultset,
strRefID,
out lNewVersion,
out strError));
}
finally
{
m_lock.ExitWriteLock();
}
#endif
}
// 运算逆波兰表，得到结果集
// parameter:
// rpn 逆波兰表
// oResultSet 结果集
// return:
// 0 成功
// -1 出错 原因可能如下:
// 1)rpn参数为null
// 2)oResultSet参数为null
// 3)栈里的某成员出错（node和result都为null）
// 4)从栈中pop()或peek()元素时，出现栈空
// 5)pop的类型，不是实际存在的类型
// 6)通过一个节点，得到结果集，即调DoQuery()函数出错
// 7)做运算时，调DpResultSetManager.Merge()函数出错
// 8)最后栈里的元素多于1，则逆波兰表出错
// 9)最后结果集为空
// -6 无足够的权限
public int ProceedRPN(ArrayList rpn,
DpResultSet resultSet,
Delegate_isConnected isConnected,
out string strError)
{
strError = "";
//???要搞清楚用不用清空
//应该清空，后面的运算使用的结果集是堆栈变量，最后把运算结果拷贝到该结果集
//DoQuery处，也应该先清空
//doItem处，一进去先清空，但再对数据库循环检索时，千万不清空
resultSet.Clear();
if (rpn == null)
{
strError = "rpn不能为null";
return(-1);
}
if (resultSet == null)
{
strError = "resultSet不能为null";
return(-1);
}
if (rpn.Count == 0)
{
return(0);
}
int ret;
// 声明栈,ReversePolishStack栈是自定义的类
// 决定用一个栈做运算，如果遇到遇到操作数，就直接push到栈里
// 遇到操作符，如果是双目，从栈里pop两项，进行运算
// 注意SUB运算是，用后一次pop的对象减前一次pop的对象
//
// oReversePolandStack的成员为ReversePolishItem,
// ReversePolishItem是一个复杂对象，
// 包含m_int(类型),m_node(节点),m_resultSet.
// 实际运用中，m_node和m_resultSet只有一项值有效，另一顶是null
// m_int用于判断哪个值有效，
// 0表示node有效，1表示resultSet有效
ReversePolishStack oReversePolandStack =
new ReversePolishStack();
//做循环
for (int i = 0; i < rpn.Count; i++)
{
XmlNode node = (XmlNode)rpn[i];
if (node.Name != "operator") //操作数直接push到栈里
{
oReversePolandStack.PushNode(node);
}
else
{
string strOpreator = DomUtil.GetAttr(node, "value");
//三个输出用于输入的参数，因为是指针，所以不用out
DpResultSet oTargetLeft = new DpResultSet();
DpResultSet oTargetMiddle = new DpResultSet();
DpResultSet oTargetRight = new DpResultSet();
//做一个两个成员的ArrayList，
//成员类型为DpResultSet，
//存放从栈里pop出的（如果是node，需要进行计算）的结果集
ArrayList oSource = new ArrayList();
oSource.Add(new DpResultSet());
oSource.Add(new DpResultSet());
try
{
for (int j = 0; j < 2; j++)
{
//类型为-1，表示node和resultSet都为null，出现错误
if (oReversePolandStack.PeekType() == -1)
{
strError = strOpreator + "时,PeekType()等于-1，则表示两项都是null，出错，返回-1<br/>";
return(-1);
}
//表示放得是node
if (oReversePolandStack.PeekType() == 0)
{
XmlNode nodePop;
nodePop = oReversePolandStack.PopNode();
if (nodePop == null)
{
strError = "nodePop不为又能为null";
return(-1);
}
// return:
// -1 出错
// -6 无权限
// 0 成功
ret = this.DoQuery(nodePop,
(DpResultSet)oSource[j],
isConnected,
out strError);
if (ret <= -1)
{
return(ret);
}
}
else
{
oSource[j] = oReversePolandStack.PopResultSet();
if (oSource[j] == null)
{
return(-1);
}
}
}
}
catch (StackUnderflowException)
{
return(-1);
}
string strDebugInfo;
//OR,AND,SUB运算都是调的DpResultSetManager.Merge()函数，
//注意参数的使用
if (strOpreator == "OR")
{
DpResultSet left = (DpResultSet)oSource[0];
left.EnsureCreateIndex(); // 确保创建了索引?
// ??????
//left.Sort();
DpResultSet right = (DpResultSet)oSource[1];
right.EnsureCreateIndex();
//right.Sort();
/*
* // new
* oTargetMiddle.EnsureCreateIndex();
*/
ret = DpResultSetManager.Merge("OR",
left,
right,
null,
oTargetMiddle,
null,
false,
out strDebugInfo,
out strError);
if (ret == -1)
{
return(-1);
}
oReversePolandStack.PushResultSet(oTargetMiddle);
continue;
}
if (strOpreator == "AND")
{
DpResultSet left = (DpResultSet)oSource[0];
left.EnsureCreateIndex();
DpResultSet right = (DpResultSet)oSource[1];
right.EnsureCreateIndex();
/*
* // new
* oTargetMiddle.EnsureCreateIndex();
*/
ret = DpResultSetManager.Merge("AND",
left,
right,
null, //oTargetLeft
oTargetMiddle,
null, //oTargetRight
false,
out strDebugInfo,
out strError);
if (ret == -1)
{
return(-1);
}
oReversePolandStack.PushResultSet(oTargetMiddle);
continue;
}
if (strOpreator == "SUB")
{
//因为使用从栈里pop，所以第0个是后面的，第1个是前面的
DpResultSet left = (DpResultSet)oSource[1];
left.EnsureCreateIndex();
DpResultSet right = (DpResultSet)oSource[0];
right.EnsureCreateIndex();
/*
* // new
* oTargetLeft.EnsureCreateIndex();
*/
ret = DpResultSetManager.Merge("SUB",
left,
right,
oTargetLeft,
oTargetMiddle, //oTargetMiddle
oTargetRight, //oTargetRight
false,
out strDebugInfo,
out strError);
if (ret == -1)
{
return(-1);
}
oReversePolandStack.PushResultSet(oTargetLeft);
continue;
}
}
}
if (oReversePolandStack.Count > 1)
{
strError = "逆波兰出错";
return(-1);
}
try
{
int nTemp = oReversePolandStack.PeekType();
//如果类型为0,表示存放的是节点
if (nTemp == 0)
{
XmlNode node = oReversePolandStack.PopNode();
// return:
// -1 出错
// -6 无权限
// 0 成功
ret = this.DoQuery(node,
resultSet,
isConnected,
out strError);
if (ret <= -1)
{
return(ret);
}
}
else if (nTemp == 1)
{
//调DpResultSet的copy函数
resultSet.Copy((DpResultSet)(oReversePolandStack.PopResultSet()));
}
else
{
strError = "oReversePolandStack的类型不可能为" + Convert.ToString(nTemp);
return(-1);
}
}
catch (StackUnderflowException)
{
strError = "peek或pop时，抛出StackUnderflowException异常";
return(-1);
}
//最后结果集为null，返回出错
if (resultSet == null)
{
strError = "运算结束后PopResultSet为null" + Convert.ToString(oReversePolandStack.PeekType());
return(-1);
}
return(0);
}
// 兑现获取浏览记录
protected override void Render(HtmlTextWriter writer)
{
string strError = "";
int nRet = 0;
OpacApplication app = (OpacApplication)this.Page.Application["app"];
SessionInfo sessioninfo = (SessionInfo)this.Page.Session["sessioninfo"];
int nPageNo = this.StartIndex / this.PageMaxLines;
SetTitle(String.IsNullOrEmpty(this.Title) == true ? this.GetString("命中结果") : this.Title);
SetResultInfo();
List<string> recpathlist = new List<string>();
/*
DropDownList formatlist = (DropDownList)FindControl("formatlist");
string strFormat = formatlist.Text;
* */
TabControl format_control = (TabControl)this.FindControl("format_control");
// 2012/11/25
if (string.IsNullOrEmpty(this.FormatName) == false)
format_control.ActiveTab = this.FormatName;
if (String.IsNullOrEmpty(format_control.ActiveTab) == true)
format_control.ActiveTab = this.DefaultFormatName;
// 换算为语言相关的字符串
if (String.IsNullOrEmpty(format_control.ActiveTab) == false)
{
format_control.ActiveTab = app.GetBrowseFormatName(format_control.ActiveTab,
this.Lang);
}
// FillTabControl(format_control);
string strFormat = format_control.ActiveTab;
if (String.IsNullOrEmpty(strFormat) == true)
strFormat = "brief";
bool bMarcVisible = this.MarcVisible;
#if NO
if (bMarcVisible == false && strFormat == "MARC")
{
base.Render(writer);
return;
}
#endif
if (this.ResultCount != 0)
{
// string strHash = channel.GetHashCode().ToString();
ArrayList aLine = null; // 各个记录的浏览列。数组的每个元素是string [] 类型
List<string> titles = new List<string>(); // 各个记录的标题
long lRet = 0;
bool bFillBrowse = false; // 浏览列是否填充过
REDO:
string strResultsetFilename = this.ResultsetFilename;
if (String.IsNullOrEmpty(strResultsetFilename) == false)
app.ResultsetLocks.LockForRead(strResultsetFilename, 500);
LibraryChannel channel = sessioninfo.GetChannel(true);
try
{
DpResultSet resultset = null;
try
{
if (String.IsNullOrEmpty(this.ResultsetFilename) == false)
{
int nOffsetStart = 0;
int nOffsetLength = -1;
ParseOffsetString(this.ResultsetOffset,
out nOffsetStart,
out nOffsetLength);
resultset = new DpResultSet(false, false);
try
{
resultset.Attach(this.ResultsetFilename,
this.ResultsetFilename + ".index");
}
catch (Exception ex)
{
this.SetErrorInfo(ex.Message); // 显示出错信息
this.ResultsetFilename = "";
// 2016/1/23
resultset.Dispose();
resultset = null;
goto REDO;
}
int nLength = 0;
if (nOffsetLength == -1)
nLength = (int)resultset.Count - nOffsetStart;
else
nLength = nOffsetLength;
aLine = new ArrayList();
for (int i = 0; i < Math.Min(nLength, this.PageMaxLines); i++)
{
int index = this.StartIndex + i + nOffsetStart;
if (index >= resultset.Count)
break;
DpRecord record = resultset[index];
titles.Add(record.BrowseText);
string[] cols = new string[1];
cols[0] = record.m_id;
// 翻译数据库名
aLine.Add(cols);
}
}
else
{
aLine = new ArrayList();
Record[] searchresults = null;
long lStart = this.StartIndex;
long lCount = this.PageMaxLines;
long lTotalCount = 0;
for (; ; )
{
lRet = // sessioninfo.Channel.
channel.GetSearchResult(
null,
this.ResultSetName,
this.StartIndex,
this.PageMaxLines,
"id,cols",
this.Lang,
out searchresults,
out strError);
if (lRet == -1 && searchresults == null)
goto ERROR1;
if (lRet != -1)
lTotalCount = lRet;
for (int k = 0; k < searchresults.Length; k++)
{
Record record = searchresults[k];
string[] cols = new string[record.Cols.Length + 1];
cols[0] = record.Path;
Array.Copy(record.Cols,
0,
cols,
1,
record.Cols.Length);
aLine.Add(cols);
}
lStart += searchresults.Length;
lCount -= searchresults.Length;
if (lStart >= lTotalCount)
break;
if (lStart + lCount > lTotalCount)
lCount = lTotalCount - lStart;
if (lCount <= 0)
break;
}
}
// 本页出现的数据库名字列表
// List<string> dbnames = new List<string>();
// 显示本页中的浏览行
for (int i = 0; i < this.PageMaxLines; i++)
{
if (this.Page.Response.IsClientConnected == false)
return;
string[] cols = null;
if (i < aLine.Count)
cols = (string[])aLine[i];
if (cols != null)
recpathlist.Add(cols[0]);
string strTitle = "";
if (i < titles.Count)
strTitle = titles[i];
PlaceHolder line = (PlaceHolder)this.FindControl("line" + Convert.ToString(i));
if (line == null)
{
PlaceHolder insertpoint = (PlaceHolder)this.FindControl("insertpoint");
PlaceHolder content = (PlaceHolder)this.FindControl("content");
line = this.NewContentLine(content, i, insertpoint);
}
BiblioControl bibliocontrol = (BiblioControl)line.FindControl("line" + Convert.ToString(i) + "_biblio");
MarcControl marccontrol = (MarcControl)line.FindControl("line" + Convert.ToString(i) + "_marc");
ItemsControl itemscontrol = (ItemsControl)line.FindControl("line" + Convert.ToString(i) + "_items");
CommentsControl commentscontrol = (CommentsControl)line.FindControl("line" + Convert.ToString(i) + "_comments");
ItemControl itemcontrol = (ItemControl)line.FindControl("line" + Convert.ToString(i) + "_item");
CommentControl commentcontrol = (CommentControl)line.FindControl("line" + Convert.ToString(i) + "_comment");
PlaceHolder layout_holder = (PlaceHolder)this.FindControl("line" + Convert.ToString(i) + "_layout");
LiteralControl no = (LiteralControl)this.FindControl("line" + Convert.ToString(i) + "_no");
Panel title = (Panel)this.FindControl("line" + Convert.ToString(i) + "_title");
HyperLink pathcontrol = (HyperLink)this.FindControl("line" + Convert.ToString(i) + "_path");
LiteralControl contentcontrol = (LiteralControl)this.FindControl("line" + Convert.ToString(i) + "_content");
CheckBox checkbox = (CheckBox)this.FindControl("line" + Convert.ToString(i) + "_checkbox");
// 序号
string strNo = " ";
if (cols != null)
strNo = Convert.ToString(i + this.StartIndex + 1);
no.Text = "<div>" + strNo + "</div>";
string strContent = " ";
// 看看路径是不是实体库路径
if (cols != null)
{
string strItemPath = cols[0];
string strItemDbName = StringUtil.GetDbName(strItemPath);
if (app.IsItemDbName(strItemDbName) == true)
{
// 插入控件
line.Controls.Add(new LiteralControl(
"<td class='item'>"
));
string strParentID = "";
nRet = itemcontrol.LoadRecord(strItemPath,
out strParentID,
out strError);
if (nRet == -1)
{
strContent = "ERROR : " + strError;
goto SKIP0;
}
string strBiblioDbName = "";
// return:
// -1 出错
// 0 没有找到
// 1 找到
nRet = app.GetBiblioDbNameByItemDbName(strItemDbName,
out strBiblioDbName,
out strError);
if (nRet == -1)
{
strContent = "ERROR : " + strError;
goto SKIP0;
}
if (nRet == 0 || String.IsNullOrEmpty(strBiblioDbName) == true)
{
if (String.IsNullOrEmpty(strError) == false)
strContent = "ERROR : " + strError;
else
strContent = "ERROR : 没有找到和实体库名 '" + strItemDbName + "' 对应的书目库名";
goto SKIP0;
}
bibliocontrol.Visible = true;
bibliocontrol.RecPath = strBiblioDbName + "/" + strParentID;
// 重新布局
this.Controls.Remove(itemcontrol);
this.Controls.Remove(bibliocontrol);
layout_holder.Controls.Add(new LiteralControl("<table class='item_and_biblio'><tr><td class='item'>"));
layout_holder.Controls.Add(itemcontrol);
layout_holder.Controls.Add(new LiteralControl("</td><td class='biblio'>"));
layout_holder.Controls.Add(bibliocontrol);
layout_holder.Controls.Add(new LiteralControl("</td></tr></table>"));
marccontrol.Visible = false;
commentcontrol.Visible = false;
itemscontrol.Visible = false;
commentscontrol.Visible = false;
goto SKIP1;
}
}
// 看看路径是不是评注库路径
if (cols != null)
{
string strItemPath = cols[0];
string strItemDbName = StringUtil.GetDbName(strItemPath);
if (app.IsCommentDbName(strItemDbName) == true)
{
// 插入控件
line.Controls.Add(new LiteralControl(
"<td class='comment'>"
));
string strParentID = "";
nRet = commentcontrol.LoadRecord(strItemPath,
out strParentID,
out strError);
if (nRet == -1)
{
strContent = "ERROR : " + strError;
goto SKIP0;
}
string strBiblioDbName = "";
// return:
// -1 出错
// 0 没有找到
// 1 找到
nRet = app.GetBiblioDbNameByCommentDbName(strItemDbName,
out strBiblioDbName,
out strError);
if (nRet == -1)
{
strContent = "ERROR : " + strError;
goto SKIP0;
}
bibliocontrol.Visible = true;
bibliocontrol.RecPath = strBiblioDbName + "/" + strParentID;
// 重新布局
this.Controls.Remove(commentcontrol);
this.Controls.Remove(bibliocontrol);
layout_holder.Controls.Add(new LiteralControl("<table class='comment_and_biblio'><tr><td class='comment'>"));
layout_holder.Controls.Add(commentcontrol);
layout_holder.Controls.Add(new LiteralControl("</td><td class='biblio'>"));
layout_holder.Controls.Add(bibliocontrol);
layout_holder.Controls.Add(new LiteralControl("</td></tr></table>"));
marccontrol.Visible = false;
itemcontrol.Visible = false;
itemscontrol.Visible = false;
commentscontrol.Visible = false;
goto SKIP1;
}
}
bool bIsBiblioType = false;
if (cols != null)
{
string strDbName = StringUtil.GetDbName(cols[0]);
// 2012/7/9
string strTempName = app.GetCfgBiblioDbName(strDbName);
if (string.IsNullOrEmpty(strTempName) == true)
{
strError = "数据库 '" + strDbName + "' 没有定义";
strContent = "ERROR : " + strError;
goto SKIP0;
}
strDbName = strTempName;
// 获得显示格式
BrowseFormat format = null;
nRet = app.GetBrowseFormat(
strDbName,
"详细",
out format,
out strError);
if (nRet == -1 || nRet == 0)
{
bIsBiblioType = false;
}
if (format != null
&& format.Type == "biblio")
{
bIsBiblioType = true;
}
}
// title
title.Controls.Add(new LiteralControl(strTitle));
// 路径
string strPath = " ";
if (cols != null)
strPath = cols[0];
pathcontrol.Text = strPath;
// 只有书目库才给出锚点
if (bIsBiblioType == true)
pathcontrol.NavigateUrl = "./book.aspx?BiblioRecPath=" + HttpUtility.UrlEncode(strPath);
else
pathcontrol.NavigateUrl = "";
// 内容
if (cols != null)
{
string strDbName = StringUtil.GetDbName(cols[0]);
string strLang = "";
// 2012/7/9
string strTempName = app.GetCfgBiblioDbName(strDbName, out strLang);
if (string.IsNullOrEmpty(strTempName) == true)
{
strError = "数据库 '" + strDbName + "' 没有定义";
strContent = "ERROR : " + strError;
goto SKIP0;
}
strDbName = strTempName;
string strBiblioRecPath = cols[0];
if (strLang != this.Lang)
{
strBiblioRecPath = app.GetLangBiblioRecPath(this.Lang,
strBiblioRecPath);
pathcontrol.Text = strBiblioRecPath;
}
if (OpacApplication.IsKernelFormatName(strFormat,
"brief") == true)
{
if (resultset != null
&& bFillBrowse == false)
{
nRet = FillBrowseCols(//sessioninfo.Channel,
channel,
ref aLine,
out strError);
if (nRet == -1)
goto SKIP0;
if (i < aLine.Count)
cols = (string[])aLine[i];
bFillBrowse = true;
}
strContent = BuildBrowseContent(app, sessioninfo,
strDbName, cols);
}
else if (OpacApplication.IsKernelFormatName(strFormat,
"MARC") == true)
{
// 插入控件
line.Controls.Add(new LiteralControl(
"<td class='marc'>"
));
bibliocontrol.Visible = false;
if (bMarcVisible == false)
marccontrol.Visible = false;
else
marccontrol.RecPath = cols[0];
itemscontrol.Visible = false;
commentscontrol.Visible = false;
itemcontrol.Visible = false;
commentcontrol.Visible = false;
goto SKIP1;
}
else
{
// 获得显示格式
BrowseFormat format = null;
nRet = app.GetBrowseFormat(
strDbName,
strFormat,
out format,
out strError);
if (nRet == -1)
goto SKIP0;
if (nRet == 0)
{
if (resultset != null
&& bFillBrowse == false)
{
nRet = FillBrowseCols(// sessioninfo.Channel,
channel,
ref aLine,
out strError);
if (nRet == -1)
goto SKIP0;
if (i < aLine.Count)
cols = (string[])aLine[i];
bFillBrowse = true;
}
// 显示格式不存在, 只好用浏览格式了
strContent = BuildBrowseContent(app, sessioninfo,
strDbName,
cols);
goto SKIP0;
}
if (format.Type == "biblio")
{
// 插入控件
line.Controls.Add(new LiteralControl(
"<td class='biblio'>"
));
/*
BookControl bookcontrol = new BookControl();
placeholder.Controls.Add(bookcontrol);
bookcontrol.BiblioRecPath = cols[0];
*/
bibliocontrol.RecPath = strBiblioRecPath; // cols[0];
marccontrol.Visible = false;
itemcontrol.Visible = false;
commentcontrol.Visible = false;
itemscontrol.BiblioRecPath = strBiblioRecPath; // cols[0];
commentscontrol.BiblioRecPath = strBiblioRecPath; // cols[0];
{
string strBiblioDbName = StringUtil.GetDbName(cols[0]);
string strCommentDbName = "";
// return:
// -1 出错
// 0 没有找到(书目库)
// 1 找到
nRet = app.GetCommentDbName(strBiblioDbName,
out strCommentDbName,
out strError);
if (nRet == -1)
goto SKIP0;
if (String.IsNullOrEmpty(strCommentDbName) == true)
commentscontrol.Visible = false;
}
goto SKIP1;
}
// 读者记录怎么办? 显示MyLibrary控件?
// 获得本地配置文件
string strLocalPath = "";
string strRemotePath = BrowseFormat.CanonicalizeScriptFileName(
strDbName,
format.ScriptFileName);
nRet = app.CfgsMap.MapFileToLocal(
channel, // GetManagerSession(app).Channel,
strRemotePath,
out strLocalPath,
out strError);
if (nRet == -1)
goto SKIP0;
if (nRet == 0)
{
// 配置文件不存在, 只好用浏览格式了
strContent = BuildBrowseContent(app, sessioninfo,
strDbName, cols);
goto SKIP0;
}
bool bFltx = false;
// 如果是一般.cs文件, 还需要获得.cs.ref配置文件
if (OpacApplication.IsCsFileName(
format.ScriptFileName) == true)
{
string strTempPath = "";
nRet = app.CfgsMap.MapFileToLocal(
channel, // GetManagerSession(app).Channel,
strRemotePath + ".ref",
out strTempPath,
out strError);
if (nRet == -1)
goto SKIP0;
bFltx = false;
}
else
{
bFltx = true;
}
// 将种记录数据从XML格式转换为HTML格式
string strBiblioXml = "";
lRet = // sessioninfo.Channel.
channel.GetBiblioInfo(
null,
cols[0],
"",
"xml",
out strBiblioXml,
out strError);
if (lRet == -1)
{
strError = "获得种记录 '" + cols[0] + "' 时出错: " + strError;
strContent = strError;
goto SKIP0;
}
if (bFltx == true)
{
KeyValueCollection result_params = null;
// string strFilterFileName = app.CfgDir + "\\opacdetail.fltx";
nRet = app.ConvertBiblioXmlToHtml(
strLocalPath,
strBiblioXml,
cols[0],
out strContent,
out result_params,
out strError);
}
else
{
nRet = app.ConvertRecordXmlToHtml(
strLocalPath,
strLocalPath + ".ref",
strBiblioXml,
cols[0], // 2009/10/18
out strContent,
out strError);
if (nRet == -2)
{
nRet = app.ConvertReaderXmlToHtml(
sessioninfo,
strLocalPath,
strLocalPath + ".ref",
strBiblioXml,
cols[0], // 2009/10/18
OperType.None,
null,
"",
out strContent,
out strError);
}
}
if (nRet == -1)
{
strContent = "ERROR : " + strError;
goto SKIP0;
}
}
}
SKIP0:
contentcontrol.Text = strContent;
bibliocontrol.Visible = false;
marccontrol.Visible = false;
itemscontrol.Visible = false;
commentscontrol.Visible = false;
itemcontrol.Visible = false;
commentcontrol.Visible = false;
SKIP1:
if (cols == null)
checkbox.Visible = false;
continue;
} // end of for
}
finally
{
if (resultset != null)
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1, out strTemp2);
}
}
}
finally
{
if (String.IsNullOrEmpty(strResultsetFilename) == false)
app.ResultsetLocks.UnlockForRead(strResultsetFilename);
#if NO
CloseManagerSession();
#endif
sessioninfo.ReturnChannel(channel);
}
#if USE_LINECOUNT
this.LineCount = Math.Max(this.LineCount, this.PageMaxLines);
#endif
/*
// 得到显示格式列表
List<string> formatnames = null;
nRet = app.GetBrowseFormatNames(dbnames,
out formatnames,
out strError);
if (nRet == -1)
throw new Exception(strError);
formatnames.Insert(0, "浏览");
// DropDownList formatlist = (DropDownList)FindControl("formatlist");
FillFormatList(formatlist, formatnames);
*/
}
else
{
// 显示空行
for (int i = 0; i < this.PageMaxLines; i++)
{
PlaceHolder line = (PlaceHolder)this.FindControl("line" + Convert.ToString(i));
if (line == null)
continue;
BiblioControl bibliocontrol = (BiblioControl)line.FindControl("line" + Convert.ToString(i) + "_biblio");
MarcControl marccontrol = (MarcControl)line.FindControl("line" + Convert.ToString(i) + "_marc");
ItemsControl itemscontrol = (ItemsControl)line.FindControl("line" + Convert.ToString(i) + "_items");
CommentsControl commentscontrol = (CommentsControl)line.FindControl("line" + Convert.ToString(i) + "_comments");
ItemControl itemcontrol = (ItemControl)line.FindControl("line" + Convert.ToString(i) + "_item");
CommentControl commentcontrol = (CommentControl)line.FindControl("line" + Convert.ToString(i) + "_comment");
CheckBox checkbox = (CheckBox)this.FindControl("line" + Convert.ToString(i) + "_checkbox");
if (bibliocontrol != null)
bibliocontrol.Visible = false;
if (marccontrol != null)
marccontrol.Visible = false;
if (itemscontrol != null)
itemscontrol.Visible = false;
if (commentscontrol != null)
commentscontrol.Visible = false;
if (itemcontrol != null)
itemcontrol.Visible = false;
if (commentcontrol != null)
commentcontrol.Visible = false;
if (checkbox != null)
checkbox.Visible = false;
}
}
this.RecPathList = StringUtil.MakePathList(recpathlist);
/*
Button add_to_mybookshelf = (Button)this.FindControl("add_to_mybookshelf");
if (this.AddToMyshelf == null)
add_to_mybookshelf.Visible = false;
* */
LoginState loginstate = GlobalUtil.GetLoginState(this.Page);
if (this.EnableAddToMyBookshelf == false
|| loginstate == LoginState.NotLogin
|| loginstate == LoginState.Public)
this.Button_AddToMyBookshelf.Visible = false;
if (this.EnableRemoveFromMyBookshelf == false
|| loginstate == LoginState.NotLogin
|| loginstate == LoginState.Public)
this.Button_RemoveFromMyBookshelf.Visible = false;
base.Render(writer);
return;
ERROR1:
SetDebugInfo("errorinfo", strError);
base.Render(writer); // 注: base.Render() 要放在使用 LibraryChannel 的 try finally 括号外边。因为 Render 页面中的其他控件的时候需要 GetChannel()。放在外边可以避免叠加获取通道导致的占用通道过多情况
}
// 运算逆波兰表，得到结果集
// parameter:
// rpn 逆波兰表
// resultSet 结果集
// return:
// 0 成功
// -1 出错 原因可能如下:
// 1)rpn参数为null
// 2)oResultSet参数为null
// 3)栈里的某成员出错（node和result都为null）
// 4)从栈中pop()或peek()元素时，出现栈空
// 5)pop的类型，不是实际存在的类型
// 6)通过一个节点，得到结果集，即调DoQuery()函数出错
// 7)做运算时，调DpResultSetManager.Merge()函数出错
// 8)最后栈里的元素多于1，则逆波兰表出错
// 9)最后结果集为空
// -6 无足够的权限
public int ProceedRPN(
SessionInfo sessioninfo,
string strOutputStyle,
ArrayList rpn,
ref DpResultSet resultSet,
ChannelHandle handle,
// Delegate_isConnected isConnected,
out string strError)
{
DateTime start_time = DateTime.Now;
Debug.WriteLine("Begin ProceedRPN()");
try
{
strError = "";
//???要搞清楚用不用清空
//应该清空，后面的运算使用的结果集是堆栈变量，最后把运算结果拷贝到该结果集
//DoQuery处，也应该先清空
//doItem处，一进去先清空，但再对数据库循环检索时，千万不清空
if (resultSet != null)
resultSet.Clear();
if (rpn == null)
{
strError = "rpn不能为null";
return -1;
}
#if NO
if (resultSet == null)
{
strError = "resultSet不能为null";
return -1;
}
#endif
if (rpn.Count == 0)
return 0;
int ret;
// 声明栈,ReversePolishStack栈是自定义的类
// 决定用一个栈做运算，如果遇到遇到操作数，就直接push到栈里
// 遇到操作符，如果是双目，从栈里pop两项，进行运算
// 注意SUB运算是，用后一次pop的对象减前一次pop的对象
//
// oReversePolandStack的成员为ReversePolishItem,
// ReversePolishItem是一个复杂对象，
// 包含m_int(类型),m_node(节点),m_resultSet.
// 实际运用中，m_node和m_resultSet只有一项值有效，另一顶是null
// m_int用于判断哪个值有效，
// 0表示node有效，1表示resultSet有效
ReversePolishStack oReversePolandStack =
new ReversePolishStack();
//做循环
for (int i = 0; i < rpn.Count; i++)
{
XmlElement node = (XmlElement)rpn[i];
if (node.Name != "operator") //操作数直接push到栈里
{
oReversePolandStack.PushNode(node);
}
else
{
string strOpreator = DomUtil.GetAttr(node, "value");
#if NO
//三个输出用于输入的参数，因为是指针，所以不用out
DpResultSet oTargetLeft = sessioninfo.NewResultSet(); // new DpResultSet();
DpResultSet oTargetMiddle = sessioninfo.NewResultSet(); // new DpResultSet();
DpResultSet oTargetRight = sessioninfo.NewResultSet(); // new DpResultSet();
#endif
//做一个两个成员的ArrayList，
//成员类型为DpResultSet，
//存放从栈里pop出的（如果是node，需要进行计算）的结果集
List<DpResultSet> oSource = new List<DpResultSet>();
oSource.Add(sessioninfo.NewResultSet()); // new DpResultSet()
oSource.Add(sessioninfo.NewResultSet()); // new DpResultSet()
try
{
for (int j = 0; j < 2; j++)
{
//类型为-1，表示node和resultSet都为null，出现错误
if (oReversePolandStack.PeekType() == -1)
{
strError = strOpreator + "时,PeekType()等于-1，则表示两项都是null，出错，返回-1<br/>";
return -1;
}
//表示放得是node
if (oReversePolandStack.PeekType() == 0)
{
XmlElement nodePop;
nodePop = oReversePolandStack.PopNode();
if (nodePop == null)
{
strError = "nodePop不为又能为null";
return -1;
}
DpResultSet temp = oSource[j];
// return:
// -1 出错
// -6 无权限
// 0 成功
ret = this.DoQuery(
sessioninfo,
strOutputStyle,
nodePop,
ref temp,
handle,
// isConnected,
out strError);
if (ret <= -1)
return ret;
if (temp != oSource[j])
{
// 2014/3/11
if (oSource[j] != null)
oSource[j].Close();
oSource[j] = temp;
}
}
else
{
DpResultSet temp = oReversePolandStack.PopResultSet();
Debug.Assert(temp != oSource[j], "");
// 2014/3/11
if (oSource[j] != null)
oSource[j].Close();
oSource[j] = temp;
if (oSource[j] == null)
{
strError = "PopResultSet() return null";
return -1;
}
}
}
}
catch (StackUnderflowException /*ex*/)
{
// 2008/12/4
string strOutXml = "";
if (node.ParentNode != null)
{
int nRet = DomUtil.GetIndentXml(node.ParentNode.OuterXml,
out strOutXml,
out strError);
}
strError = strOpreator + " 是二元操作符，它缺乏操作数。";
if (String.IsNullOrEmpty(strOutXml) == false)
strError += "\r\n" + strOutXml;
// strError = "StackUnderflowException :" + ex.Message;
return -1;
}
// string strDebugInfo;
//OR,AND,SUB运算都是调的DpResultSetManager.Merge()函数，
//注意参数的使用
if (strOpreator == "OR")
{
bool bOutputKeyCount = StringUtil.IsInList("keycount", strOutputStyle);
bool bOutputKeyID = StringUtil.IsInList("keyid", strOutputStyle);
DpResultSet left = oSource[1];
DpResultSet right = oSource[0];
#if DEBUG
Debug.Assert(left.IsClosed == false, "");
Debug.Assert(right.IsClosed == false, "");
#endif
{
// 直接相加
if (left.Count == 0)
{
oReversePolandStack.PushResultSet(
right
);
// 2014/3/11
Debug.Assert(left != right, "");
left.Close();
}
else if (right.Count == 0)
{
oReversePolandStack.PushResultSet(
left
);
// 2014/3/11
Debug.Assert(left != right, "");
right.Close();
}
else
{
if (EnsureSorted(left, handle, out strError) == -1)
return -1;
if (EnsureSorted(right, handle, out strError) == -1)
return -1;
// return:
// -1 出错
// 0 没有交叉部分
// 1 有交叉部分
ret = DpResultSetManager.IsCross(left,
right,
out strError);
if (ret == -1)
return -1;
if (ret == 0)
{
DpResultSet left_save = left;
// 注意：函数执行过程，可能交换 left 和 right。也就是说返回后， left == right
ret = DpResultSetManager.AddResults(ref left,
right,
out strError);
if (ret == -1)
return -1;
oReversePolandStack.PushResultSet(
left
);
// 2014/3/11
if (left != right)
{
Debug.Assert(left_save == left, "");
right.Close();
}
else
{
Debug.Assert(left_save != left, "");
left_save.Close();
}
}
else
{
if (left.Asc != right.Asc)
{
right.Asc = left.Asc;
right.Sorted = false;
}
if (EnsureSorted(left, handle, out strError) == -1)
return -1;
if (EnsureSorted(right, handle, out strError) == -1)
return -1;
{
DpResultSet oTargetMiddle = sessioninfo.NewResultSet(); // new DpResultSet();
StringBuilder debugInfo = null;
ret = DpResultSetManager.Merge(LogicOper.OR,
left,
right,
strOutputStyle,
null,
oTargetMiddle,
null,
// false,
querystop,
handle,
ref debugInfo,
out strError);
if (ret == -1)
return -1;
oReversePolandStack.PushResultSet(oTargetMiddle);
// 2014/3/11
Debug.Assert(left != oTargetMiddle, "");
Debug.Assert(right != oTargetMiddle, "");
left.Close();
right.Close();
}
}
}
}
continue;
}
if (strOpreator == "AND")
{
DpResultSet left = oSource[1];
DpResultSet right = oSource[0];
#if DEBUG
Debug.Assert(left.IsClosed == false, "");
Debug.Assert(right.IsClosed == false, "");
#endif
if (left.Asc != right.Asc)
{
right.Asc = left.Asc;
right.Sorted = false;
}
if (EnsureSorted(left, handle, out strError) == -1)
return -1;
if (EnsureSorted(right, handle, out strError) == -1)
return -1;
// 优化
if (left.Count == 0)
{
oReversePolandStack.PushResultSet(
left
);
// 2014/3/11
Debug.Assert(left != right, "");
right.Close();
}
else if (right.Count == 0)
{
oReversePolandStack.PushResultSet(
right
);
// 2014/3/11
Debug.Assert(left != right, "");
left.Close();
}
else
{
DpResultSet oTargetMiddle = sessioninfo.NewResultSet(); // new DpResultSet();
StringBuilder debugInfo = null;
ret = DpResultSetManager.Merge(LogicOper.AND,
left,
right,
strOutputStyle,
null, //oTargetLeft
oTargetMiddle,
null, //oTargetRight
// false,
querystop,
handle,
ref debugInfo,
out strError);
if (ret == -1)
return -1;
oReversePolandStack.PushResultSet(oTargetMiddle);
// 2014/3/11
Debug.Assert(left != oTargetMiddle, "");
Debug.Assert(right != oTargetMiddle, "");
left.Close();
right.Close();
}
continue;
}
if (strOpreator == "SUB")
{
//因为使用从栈里pop，所以第0个是后面的，第1个是前面的
DpResultSet left = oSource[1];
DpResultSet right = oSource[0];
#if DEBUG
Debug.Assert(left.IsClosed == false, "");
Debug.Assert(right.IsClosed == false, "");
#endif
if (left.Asc != right.Asc)
{
right.Asc = left.Asc;
right.Sorted = false;
}
if (EnsureSorted(left, handle, out strError) == -1)
return -1;
if (EnsureSorted(right, handle, out strError) == -1)
return -1;
// 优化
if (left.Count == 0)
{
oReversePolandStack.PushResultSet(
left
);
// 2014/3/11
Debug.Assert(left != right, "");
right.Close();
}
else if (right.Count == 0)
{
oReversePolandStack.PushResultSet(
left
);
// 2014/3/11
Debug.Assert(left != right, "");
right.Close();
}
else
{
DpResultSet oTargetLeft = sessioninfo.NewResultSet(); // new DpResultSet();
StringBuilder debugInfo = null;
ret = DpResultSetManager.Merge(LogicOper.SUB,
left,
right,
strOutputStyle,
oTargetLeft,
null, //oTargetMiddle
null, //oTargetRight
// false,
querystop,
handle,
ref debugInfo,
out strError);
if (ret == -1)
{
return -1;
}
oReversePolandStack.PushResultSet(oTargetLeft);
// 2014/3/11
Debug.Assert(left != oTargetLeft, "");
Debug.Assert(right != oTargetLeft, "");
left.Close();
right.Close();
}
continue;
}
}
}
if (oReversePolandStack.Count > 1)
{
strError = "逆波兰出错";
return -1;
}
try
{
int nTemp = oReversePolandStack.PeekType();
//如果类型为0,表示存放的是节点
if (nTemp == 0)
{
XmlElement node = oReversePolandStack.PopNode();
// return:
// -1 出错
// -6 无权限
// 0 成功
ret = this.DoQuery(
sessioninfo,
strOutputStyle,
node,
ref resultSet,
handle,
// isConnected,
out strError);
if (ret <= -1)
return ret;
}
else if (nTemp == 1)
{
// 调DpResultSet的copy函数
// TODO: 测算这个Copy所花费的时间。
// resultSet.Copy((DpResultSet)(oReversePolandStack.PopResultSet()));
resultSet = (DpResultSet)(oReversePolandStack.PopResultSet());
}
else
{
strError = "oReversePolandStack的类型不可能为" + Convert.ToString(nTemp);
return -1;
}
}
catch (StackUnderflowException)
{
strError = "peek或pop时，抛出StackUnderflowException异常";
return -1;
}
//最后结果集为null，返回出错
if (resultSet == null)
{
strError = "运算结束后PopResultSet为null" + Convert.ToString(oReversePolandStack.PeekType());
return -1;
}
return 0;
}
finally
{
TimeSpan delta = DateTime.Now - start_time;
Debug.WriteLine("End ProceedRPN() 耗时 " + delta.ToString());
}
}
int BuildRssFile(
LibraryChannel channel,
string strResultsetFilename,
long nMaxCount,
string strDirection,
string strChannelTitle,
string strChannelLink,
string strSelfLink,
string strChannelDescription,
string strOutputFilename,
out int nOutputCount,
out string strError)
{
strError = "";
nOutputCount = 0;
int nRet = 0;
long lRet = 0;
if (String.IsNullOrEmpty(strOutputFilename) == true)
strOutputFilename = strResultsetFilename + ".rss";
bool bDone = false;
/*
if (File.Exists(strOutputFilename) == true)
return 0;
* */
XmlTextWriter writer = new XmlTextWriter(strOutputFilename,
Encoding.UTF8);
writer.Formatting = Formatting.Indented;
writer.Indentation = 4;
DpResultSet resultset = null;
this.App.ResultsetLocks.LockForRead(strResultsetFilename + ".rss", 500);
try
{
resultset = new DpResultSet(false, false);
try
{
resultset.Attach(strResultsetFilename,
strResultsetFilename + ".index");
}
catch (Exception ex)
{
strError = "打开结果集文件时出错: " + ex.Message;
return -1;
}
try
{
writer.WriteStartDocument();
writer.WriteStartElement("rss");
writer.WriteAttributeString("version", "2.0");
writer.WriteAttributeString("xmlns", "dc", null,
"http://purl.org/dc/elements/1.1/");
writer.WriteAttributeString("xmlns", "atom", null,
"http://www.w3.org/2005/Atom");
writer.WriteAttributeString("xmlns", "content", null,
"http://purl.org/rss/1.0/modules/content/");
writer.WriteStartElement("channel");
writer.WriteStartElement("title");
writer.WriteString(strChannelTitle);
writer.WriteEndElement();
writer.WriteStartElement("link");
writer.WriteString(strChannelLink);
writer.WriteEndElement();
writer.WriteStartElement("atom", "link",
"http://www.w3.org/2005/Atom");
writer.WriteAttributeString("href", strSelfLink);
writer.WriteAttributeString("rel", "self");
writer.WriteAttributeString("type", "application/rss+xml");
writer.WriteEndElement();
if (string.IsNullOrEmpty(strChannelDescription) == false)
strChannelDescription = strChannelLink;
writer.WriteStartElement("description");
writer.WriteString(strChannelDescription);
writer.WriteEndElement();
// 2011/7/4
DateTime now = DateTime.Now.ToUniversalTime();
writer.WriteStartElement("pubDate");
writer.WriteString(DateTimeUtil.Rfc1123DateTimeString(now));
writer.WriteEndElement();
writer.WriteStartElement("lastBuildDate");
writer.WriteString(DateTimeUtil.Rfc1123DateTimeString(now));
writer.WriteEndElement();
long nCount = resultset.Count;
long nStart = 0;
if (strDirection == "head" && nMaxCount != -1)
nCount = Math.Min(nMaxCount, nCount);
else if (strDirection == "tail" && nMaxCount != -1)
{
nStart = nCount - nMaxCount;
if (nStart < 0)
nStart = 0;
}
for (long i = nStart; i < nCount; i++)
{
if (this.m_bClosed == true || this.Stopped == true)
{
strError = "中断";
return -1;
}
DpRecord record = resultset[i];
string strPath = record.ID;
// TODO: 对于实体库记录或者评注库记录，可以检索其从属的书目记录来取得书名等？
// 或者评注库记录本身就有文章名
// 实体库记录可以link到 book.aspx?itemrecpath=???
string strBiblioDbName = "";
// string strDbName = ResPath.GetDbName(strPath);
string strDbName = StringUtil.GetDbName(strPath);
string strDbType = this.App.GetDbType(strDbName,
out strBiblioDbName);
if (strDbType == null)
{
strError = "数据库 '" + strDbName + "' 的类型无法识别";
return -1;
}
string strItemMetadata = "";
XmlDocument itemdom = null;
string strBiblioRecPath = "";
if (strDbType == "item" || strDbType == "comment")
{
string strStyle = LibraryChannel.GETRES_ALL_STYLE;
string strItemXml = "";
byte[] item_timestamp = null;
string strItemOutputPath = "";
// TODO: 优化为成批获取
lRet = channel.GetRes(null,
strPath,
strStyle,
out strItemXml,
out strItemMetadata,
out item_timestamp,
out strItemOutputPath,
out strError);
if (lRet == -1)
{
strError = "获取记录 '" + strPath + "' 时发生错误: " + strError;
return -1;
}
nRet = OpacApplication.LoadToDom(strItemXml,
out itemdom,
out strError);
if (nRet == -1)
{
strError = "装载记录 '" + strPath + "' 进入XML DOM时发生错误: " + strError;
return -1;
}
string strParentID = DomUtil.GetElementText(itemdom.DocumentElement,
"parent");
strBiblioRecPath = strBiblioDbName + "/" + strParentID;
}
else if (strDbType == "biblio")
{
strBiblioRecPath = strPath;
}
// 从数据库中获取
string strBiblioXml = "";
byte[] timestamp = null;
string[] formats = new string[3];
formats[0] = "xml";
formats[1] = "summary";
formats[2] = "metadata";
string[] results = null;
lRet = channel.GetBiblioInfos(
null,
strBiblioRecPath,
"",
formats,
out results,
out timestamp,
out strError);
if (lRet == -1)
return -1;
if (lRet == 0)
continue; // TODO: 产生一条占位记录?
/*
LibraryServerResult result = this.App.GetBiblioInfos(
sessioninfo,
strBiblioRecPath,
formats,
out results,
out timestamp);
if (result.Value == -1)
{
strError = result.ErrorInfo;
return -1;
}
if (result.Value == 0)
continue; // TODO: 产生一条占位记录?
*/
if (results == null || results.Length != 3)
{
strError = "results error {5E0FC5A1-819D-4655-AB3B-5CE6AAAB1BFE}";
return -1;
}
strBiblioXml = results[0];
string strSummary = results[1];
string strBiblioMetaData = results[2];
string strMetaData = "";
if (strDbType == "biblio")
strMetaData = strBiblioMetaData;
else
strMetaData = strItemMetadata;
// 取metadata
Hashtable values = StringUtil.ParseMetaDataXml(strMetaData,
out strError);
if (values == null)
{
strError = "parse metadata error: " + strError;
return -1;
}
string strPubDate = "";
string strLastModified = (string)values["lastmodified"];
if (String.IsNullOrEmpty(strLastModified) == false)
{
DateTime time = DateTime.Parse(strLastModified);
strPubDate = DateTimeUtil.Rfc1123DateTimeString(time.ToUniversalTime());
}
string strTitle = "";
string strLink = "";
List<string> authors = null;
if (strDbType == "biblio")
strLink = this.App.OpacServerUrl + "/book.aspx?BiblioRecPath=" + HttpUtility.UrlEncode(strBiblioRecPath);
else if (strDbType == "item")
strLink = this.App.OpacServerUrl + "/book.aspx?ItemRecPath=" + HttpUtility.UrlEncode(strPath) + "#active";
else if (strDbType == "comment")
strLink = this.App.OpacServerUrl + "/book.aspx?CommentRecPath=" + HttpUtility.UrlEncode(strPath) + "#active";
if (strDbType == "biblio"
|| strDbType == "item")
{
nRet = GetBiblioInfos(
strBiblioXml,
out strTitle,
out authors,
out strError);
}
else if (strDbType == "comment")
{
nRet = GetCommentInfos(
itemdom,
out strTitle,
out authors,
out strError);
}
string strItemSummary = "";
string strItemSummaryHtml = "";
if (strDbType == "item" || strDbType == "comment")
{
// 获得实体记录或者评注记录的摘要
nRet = GetSummary(strDbType,
itemdom,
"text",
out strItemSummary,
out strError);
if (nRet == -1)
{
strError = "创建记录 '" + strPath + "' 的摘要信息时发生错误: " + strError;
return -1;
}
// 获得实体记录或者评注记录的摘要
nRet = GetSummary(strDbType,
itemdom,
"html",
out strItemSummaryHtml,
out strError);
if (nRet == -1)
{
strError = "创建记录 '" + strPath + "' 的摘要信息时发生错误: " + strError;
return -1;
}
}
writer.WriteStartElement("item");
writer.WriteAttributeString("id", (i + 1).ToString());
writer.WriteStartElement("title");
writer.WriteString(strTitle);
writer.WriteEndElement();
foreach (string strAuthor in authors)
{
// writer.WriteStartElement("author");
writer.WriteStartElement("dc", "creator",
"http://purl.org/dc/elements/1.1/");
writer.WriteString(strAuthor);
writer.WriteEndElement();
}
if (String.IsNullOrEmpty(strSummary) == false
|| String.IsNullOrEmpty(strItemSummary) == false)
{
writer.WriteStartElement("description");
if (String.IsNullOrEmpty(strItemSummary) == false)
{
if (strDbType == "comment")
writer.WriteString(strItemSummary + "\r\n\r\n从属于： " + strSummary);
else
writer.WriteString(strItemSummary + "\r\n\r\n" + strSummary);
}
else
writer.WriteString(strSummary);
writer.WriteEndElement();
}
// <content:encoded>
if (String.IsNullOrEmpty(strItemSummaryHtml) == false)
{
writer.WriteStartElement("content", "encoded", "http://purl.org/rss/1.0/modules/content/");
if (strDbType == "comment")
writer.WriteCData(strItemSummaryHtml + "<br/><br/>从属于： " + strSummary);
else
writer.WriteCData(strItemSummaryHtml + "<br/><br/>" + strSummary);
writer.WriteEndElement();
}
writer.WriteStartElement("link");
writer.WriteString(strLink);
writer.WriteEndElement();
// 2011/7/4
writer.WriteStartElement("guid");
writer.WriteAttributeString("isPermaLink", "true");
writer.WriteString(strLink);
writer.WriteEndElement();
writer.WriteStartElement("pubDate");
writer.WriteString(strPubDate);
writer.WriteEndElement();
writer.WriteEndElement(); // </item>
nOutputCount++;
}
}
finally
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1, out strTemp2);
}
writer.WriteEndElement(); // </channel>
writer.WriteEndElement(); // </rss>
writer.WriteEndDocument();
bDone = true;
}
finally
{
// this.App.EndLoop(strOutputFilename, true);
this.App.ResultsetLocks.UnlockForRead(strResultsetFilename + ".rss");
writer.Close();
if (bDone == false)
File.Delete(strOutputFilename); // 不完整的文件要删除掉才行
}
return 0;
}
// 从结果集中提取指定范围的记录
// parameter:
// strRanges 范围
// strStyle 样式,以逗号分隔，id:表示取id,cols表示取浏览格式,xml表示取xml记录体
// strLang 语言版本，用来获得记录路径
// richRecords 得到的记录数组，成员为类型为Record
// result:
// -1 出错
// >=0 结果集的总数
public long API_GetRichRecords(
DpResultSet resultset,
string strRanges,
string strLang,
string strStyle,
out RichRecord[] richRecords,
out string strError)
{
strError = "";
richRecords = null;
int nCurCount = 0;
List <RichRecord> aRichRecord = new List <RichRecord>();
string strFormat = StringUtil.GetStyleParam(strStyle, "format");
RangeList rangeList = new RangeList(strRanges);
for (int i = 0; i < rangeList.Count; i++)
{
RangeItem rangeItem = (RangeItem)rangeList[i];
int nStart = (int)rangeItem.lStart;
int nLength = (int)rangeItem.lLength;
if (nLength == 0)
{
continue;
}
// long lPos = 0; // 应该用快速方式，不应用[]??? 2006/3/29
for (int j = 0; j < nLength; j++)
{
int nRet = 0;
DpRecord dpRecord = resultset[j + nStart];
RichRecord richRecord = new RichRecord();
DbPath dbpath = new DbPath(dpRecord.ID);
Database db = this.app.Dbs.GetDatabaseSafety(dbpath.Name);
if (db == null) //也应放到本条的记录出错信息里
{
strError = "没有找到数据库'" + dbpath.Name + "'，换语言版本时出错";
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = KernelApplication.Ret2ErrorCode(nRet);
richRecord.Result.ErrorString = strError;
}
else
{
// 记录路径
if (StringUtil.IsInList("id", strStyle, true) == true ||
StringUtil.IsInList("path", strStyle, true) == true)
{
richRecord.Path = db.GetCaptionSafety(strLang) + "/" + dbpath.CompressedID;
}
// 浏览列
if (StringUtil.IsInList("cols", strStyle, true) == true)
{
string[] cols = null;
nRet = db.GetCols(
strFormat,
dbpath.ID10,
"",
0,
out cols);
// 2013/1/14
if (nRet == -1)
{
if (cols != null && cols.Length > 0)
{
strError = cols[0];
}
else
{
strError = "GetCols() error";
}
return(-1);
}
richRecord.Cols = cols;
}
bool bXml = false;
bool bTimestamp = false;
if (StringUtil.IsInList("xml", strStyle, true) == true)
{
bXml = true;
}
if (StringUtil.IsInList("timestamp", strStyle, true) == true)
{
bTimestamp = true;
}
if (bXml == true ||
bTimestamp == true)
{
string strGetStyle = ""; //"data,timestamp"; // ,outputpath, metadata
if (bTimestamp == true)
{
StringUtil.SetInList(ref strGetStyle, "timestamp", true);
}
if (bXml == true)
{
StringUtil.SetInList(ref strGetStyle, "data", true);
}
int nStart0 = 0;
int nLength0 = -1;
int nMaxLength = 300 * 1024; // 每次最多获取300K
int nTotalLength = 0;
string strOutputID = "";
byte[] baTotal = null;
byte[] baOutputTimestamp = null;
int nAdditionError = 0;
string strMetadata = "";
for (; ;)
{
byte[] baData = null;
long lRet = db.GetXml(dbpath.ID,
"", // strXPath,
nStart0,
nLength0,
nMaxLength,
strGetStyle,
out baData,
out strMetadata,
out strOutputID,
out baOutputTimestamp,
true,
out nAdditionError,
out strError);
if (lRet <= -1)
{
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = KernelApplication.Ret2ErrorCode(nAdditionError); // nRet?
richRecord.Result.ErrorString = strError;
goto CONTINUE;
}
nTotalLength = (int)lRet;
// 如果数据体太大
if (nTotalLength > QUOTA_SIZE)
{
richRecord.Result.Value = -1;
richRecord.Result.ErrorCode = ErrorCodeValue.CommonError;
richRecord.Result.ErrorString = "数据超过1M";
goto CONTINUE;
}
baTotal = ByteArray.Add(baTotal, baData);
nStart0 += baData.Length;
if (nStart0 >= nTotalLength)
{
break;
}
}
// 记录体
// 转换成字符串
if (StringUtil.IsInList("xml", strStyle, true) == true)
{
richRecord.Xml = ByteArray.ToString(baTotal);
}
// 时间戳?
if (StringUtil.IsInList("timestamp", strStyle, true) == true)
{
richRecord.baTimestamp = baOutputTimestamp;
}
// string strOutputPath = strDbName + "/" + strOutputID;
}
// 记录体
if (StringUtil.IsInList("xml", strStyle, true) == true)
{
/*
* nRet = db.GetXmlDataSafety(dbpath.ID,
* out richRecord.Xml,
* out strError);
* if (nRet <= -1)
* {
* richRecord.Result.Value = -1;
* richRecord.Result.ErrorCode = RmswsApplication.Ret2ErrorCode(nRet);
* richRecord.Result.ErrorString = strError;
* }
* */
}
}
CONTINUE:
aRichRecord.Add(richRecord);
Thread.Sleep(0);
nCurCount++;
// 如果超出最大范围，则停止
if (nCurCount >= SessionInfo.MaxRecordsCountPerApi)
{
break;
}
}
}
richRecords = new RichRecord[aRichRecord.Count];
for (int i = 0; i < richRecords.Length; i++)
{
richRecords[i] = aRichRecord[i];
}
return(resultset.Count);
}
// 检索
// parameter:
// strQuery 检索式XML字符串
// resultSet 结果集,用于存放检索结果
// oUser 帐户对象,用于检索该帐户对某库是否有读权限
// 为null,则不进行权限的检查，即按有权限算
// isConnected delegate对象,用于通讯是否连接正常
// 为null，则不调delegate函数
// strError out参数，返回出错信息
// return:
// -1 出错
// -6 权限不够
// 0 成功
// 线: 安全的
public int Search(string strQuery,
DpResultSet resultSet,
User oUser,
Delegate_isConnected isConnected,
out string strError)
{
strError = "";
//对库集合加读锁*********************************
m_lock.AcquireReaderLock(m_nTimeOut);
#if DEBUG_LOCK
this.WriteDebugInfo("Search()，对库集合加读锁。");
#endif
try
{
if (String.IsNullOrEmpty(strQuery) == true)
{
strError = "Search()调用错误，strQuery不能为null或空字符串";
return -1;
}
// 一进来先给结果集的m_strQuery成员赋值，
// 不管是否是合法的XML，在用结果集的时候再判断
resultSet.m_strQuery = strQuery;
XmlDocument dom = new XmlDocument();
dom.PreserveWhitespace = true; //设PreserveWhitespace为true
try
{
dom.LoadXml(strQuery);
}
catch (Exception ex)
{
strError += "检索式字符串加载到dom出错，原因：" + ex.Message + "\r\n"
+ "检索式字符串如下:\r\n"
+ strQuery;
return -1;
}
//创建Query对象
Query query = new Query(this,
oUser,
dom);
//进行检索
// return:
// -1 出错
// -6 无权限
// 0 成功
int nRet = query.DoQuery(dom.DocumentElement,
resultSet,
isConnected,
out strError);
if (nRet <= -1)
return nRet;
}
finally
{
//****************对库集合解读锁**************
m_lock.ReleaseReaderLock();
#if DEBUG_LOCK
this.WriteDebugInfo("Search()，对库集合解读锁。");
#endif
}
return 0;
}
// 检索单元item的信息，对库进行检索
// parameter:
// nodeItem item节点
// resultSet 结果集。返回时不能确保结果集已经排序。需要看resultset.Sorted成员
// 传进结果集,????????每次清空，既然每次清空，那还不如返回一个结果集呢
// isConnected 是否连接
// strError out参数，返回出错信息
// return:
// -1 出错
// -6 无足够的权限
// 0 成功
public int doItem(
SessionInfo sessioninfo,
string strOutputStyle,
XmlElement nodeItem,
ref DpResultSet resultSet,
ChannelHandle handle,
// Delegate_isConnected isConnected,
out string strError)
{
strError = "";
if (nodeItem == null)
{
strError = "doItem() nodeItem参数为null.";
return -1;
}
if (resultSet == null)
{
strError = "doItem() oResult参数为null.";
return -1;
}
string strResultSetName = nodeItem.GetAttribute("resultset");
if (string.IsNullOrEmpty(strResultSetName) == false)
{
resultSet.Close();
resultSet = null;
DpResultSet source = null;
if (KernelApplication.IsGlobalResultSetName(strResultSetName) == true)
{
source = this.m_dbColl.KernelApplication.ResultSets.GetResultSet(strResultSetName.Substring(1), false);
}
else
{
source = sessioninfo.GetResultSet(strResultSetName, false);
}
if (source == null)
{
strError = "没有找到名为 '" + strResultSetName + "' 的结果集对象";
return -1;
}
resultSet = source.Clone("handle");
resultSet.ReadOnly = true;
return 0;
}
//先清空一下
resultSet.Clear();
int nRet;
//调processRelation对检索单元的成员检查是否存在矛盾
//如果返回0，则可能对item的成员进行了修改，所以后面重新提取内容
nRet = ProcessRelation(nodeItem);
if (nRet == -1)
{
// strError = "doItem()里调processRelation出错";
strError = "检索式局部有错: " + nodeItem.OuterXml;
return -1;
}
// 根据nodeItem得到检索信息
string strTarget;
string strWord;
string strMatch;
string strRelation;
string strDataType;
string strIdOrder;
string strKeyOrder;
string strOrderBy;
string strHint = "";
int nMaxCount;
nRet = QueryUtil.GetSearchInfo(nodeItem,
strOutputStyle,
out strTarget,
out strWord,
out strMatch,
out strRelation,
out strDataType,
out strIdOrder,
out strKeyOrder,
out strOrderBy,
out nMaxCount,
out strHint,
out strError);
if (nRet == -1)
return -1;
bool bSearched = false;
bool bNeedSort = false;
bool bFirst = StringUtil.IsInList("first", strHint); // 是否为 命中则停止继续检索
// 将 target 以 ; 号分成多个库
string[] aDatabase = strTarget.Split(new Char[] { ';' });
foreach (string strOneDatabase in aDatabase)
{
if (strOneDatabase == "")
continue;
string strDbName;
string strTableList;
// 拆分库名与途径
nRet = DatabaseUtil.SplitToDbNameAndForm(strOneDatabase,
out strDbName,
out strTableList,
out strError);
if (nRet == -1)
return -1;
// 得到库
Database db = m_dbColl.GetDatabase(strDbName);
if (db == null)
{
strError = "未找到'" + strDbName + "'库";
return -1;
}
// 2009/7/19
if (db.InRebuildingKey == true)
{
strError = "数据库 '" + db.GetCaption(null) + "' 正处在重建检索点状态，不能进行检索...";
return -1;
}
string strTempRecordPath = db.GetCaption("zh-CN") + "/" + "record";
string strExistRights = "";
bool bHasRight = this.m_oUser.HasRights(strTempRecordPath,
ResType.Record,
"read",
out strExistRights);
if (bHasRight == false)
{
strError = "您的帐户名为'" + m_oUser.Name + "'" +
",对'" + strDbName + "'" +
"数据库中的记录没有'读(read)'权限，目前的权限为'" + strExistRights + "'。";
return -6;
}
SearchItem searchItem = new SearchItem();
searchItem.TargetTables = strTableList;
searchItem.Word = strWord;
searchItem.Match = strMatch;
searchItem.Relation = strRelation;
searchItem.DataType = strDataType;
searchItem.IdOrder = strIdOrder;
searchItem.KeyOrder = strKeyOrder;
searchItem.OrderBy = strOrderBy;
searchItem.MaxCount = nMaxCount;
// 注: SearchByUnion不清空resultSet，从而使多个库的结果集放在一起
string strWarningInfo = "";
// -1 出错
// 0 成功
// 1 成功，但resultset需要再行排序一次
nRet = db.SearchByUnion(
strOutputStyle,
searchItem,
handle,
// isConnected,
resultSet,
this.m_nWarningLevel,
out strError,
out strWarningInfo);
if (nRet == -1)
return -1;
bSearched = true;
if (nRet == 1)
bNeedSort = true;
if (nRet >= 1 && bFirst == true)
break;
}
// 2010/5/17
if (bSearched == true)
{
// 2010/5/11
resultSet.EnsureCreateIndex(); // 确保创建了索引
// 排序
// TODO: 其实可以使用EnsureSorted()函数
if (bNeedSort == true)
{
if (DoSort(resultSet, handle/*isConnected*/) == true)
{
strError = "前端中断";
return -1;
}
}
// TODO: 也可以延迟排序，本函数返回一个值表希望排序。等到最后不得不排序时候再排序最好了
//resultSet.RemoveDup();
}
return 0;
}
// 根据用户名从库中查找用户记录，得到用户对象
// 对象尚未进入集合, 因此无需为对象加锁
// parameters:
// strBelongDb 用户从属的数据库,中文名称
// user out参数，返回帐户对象
// strError out参数，返回出错信息
// return:
// -1 出错
// 0 未找到帐户
// 1 找到了
// 线：安全
internal int ShearchUser(string strUserName,
out User user,
out string strError)
{
user = null;
strError = "";
int nRet = 0;
DpResultSet resultSet = new DpResultSet();
//*********对帐户库集合加读锁***********
m_lock.AcquireReaderLock(m_nTimeOut);
#if DEBUG_LOCK
this.WriteDebugInfo("ShearchUser()，对帐户库集合加读锁。");
#endif
try
{
// return:
// -1 出错
// 0 成功
nRet = this.SearchUserInternal(strUserName,
resultSet,
out strError);
if (nRet == -1)
return -1;
}
finally
{
//*********对帐户库集合解读锁*************
m_lock.ReleaseReaderLock();
#if DEBUG_LOCK
this.m_dbColl.WriteDebugInfo("ShearchUser()，对帐户库集合解读锁。");
#endif
}
// 根据用户名没找到对应的帐户记录
long lCount = resultSet.Count;
if (lCount == 0)
return 0;
if (lCount > 1)
{
strError = "用户名'" + strUserName + "'对应多条记录";
return -1;
}
// 按第一个帐户算
DpRecord record = (DpRecord)resultSet[0];
// 创建一个DpPsth实例
DbPath path = new DbPath(record.ID);
// 找到指定帐户数据库
Database db = this.GetDatabaseSafety(path.Name);
if (db == null)
{
strError = "未找到'" + strUserName + "'帐户对应的名为'" + path.Name + "'的数据库对象";
return -1;
}
// 从帐户库中找到记录
string strXml = "";
// return:
// -1 出错
// -4 记录不存在
// 0 正确
nRet = db.GetXmlDataSafety(path.ID,
out strXml,
out strError);
if (nRet <= -1) // 将-4与-1都作为-1返回
return -1;
//加载到dom
XmlDocument dom = new XmlDocument();
//dom.PreserveWhitespace = true; //设PreserveWhitespace为true
try
{
dom.LoadXml(strXml);
}
catch (Exception ex)
{
strError = "加载用户 '" + strUserName + "' 的帐户记录到dom时出错,原因:" + ex.Message;
return -1;
}
user = new User();
// return:
// -1 出错
// 0 成功
nRet = user.Initial(
record.ID,
dom,
db,
this,
out strError);
if (nRet == -1)
return -1;
return 1;
}
// return:
// -2 remoting服务器连接失败。驱动程序尚未启动
// -1 出错
// >=0 实际发送给接口程序的事项数目
static int CreateFingerprintCache(DpResultSet resultset,
out string strError)
{
strError = "";
int nRet = 0;
ShowMessage("加入高速缓存");
try
{
if (resultset == null)
{
// 清空以前的全部缓存内容，以便重新建立
// return:
// -2 remoting服务器连接失败。驱动程序尚未启动
// -1 出错
// 0 成功
nRet = AddItems(
//channel,
null,
out strError);
if (nRet == -1)
{
return(-1);
}
if (nRet == -2)
{
return(-2);
}
return(0);
}
int nSendCount = 0;
long nCount = resultset.Count;
List <FingerprintItem> items = new List <FingerprintItem>();
for (long i = 0; i < nCount; i++)
{
DpRecord record = resultset[i];
string strTimestamp = "";
string strBarcode = "";
string strFingerprint = "";
ParseResultItemString(record.BrowseText,
out strTimestamp,
out strBarcode,
out strFingerprint);
// TODO: 注意读者证条码号为空的，不要发送出去
FingerprintItem item = new FingerprintItem();
item.ReaderBarcode = strBarcode;
item.FingerprintString = strFingerprint;
items.Add(item);
if (items.Count >= 100)
{
// return:
// -2 remoting服务器连接失败。驱动程序尚未启动
// -1 出错
// 0 成功
nRet = AddItems(
//channel,
items,
out strError);
if (nRet == -1)
{
return(-1);
}
if (nRet == -2)
{
return(-2);
}
nSendCount += items.Count;
items.Clear();
}
}
if (items.Count > 0)
{
// return:
// -2 remoting服务器连接失败。驱动程序尚未启动
// -1 出错
// 0 成功
nRet = AddItems(
//channel,
items,
out strError);
if (nRet == -1)
{
return(-1);
}
if (nRet == -2)
{
return(-2);
}
nSendCount += items.Count;
}
// Console.Beep(); // 表示读取成功
return(nSendCount);
}
finally
{
}
}
// 从所有帐户库的所有表中查找帐户
// parameter
// strUserName 用户名
// resultSet 结果集,用于存放查找到的用户
// strError out参数，返回出错信息
// return:
// -1 出错
// 0 成功
// 线：不安全
private int SearchUserInternal(string strUserName,
DpResultSet resultSet,
out string strError)
{
strError = "";
foreach (Database db in this)
{
if (StringUtil.IsInList("account", db.GetDbType()) == false)
continue;
if (strUserName.Length > db.KeySize)
continue;
string strWarning = "";
SearchItem searchItem = new SearchItem();
searchItem.TargetTables = "";
searchItem.Word = strUserName;
searchItem.Match = "exact";
searchItem.Relation = "=";
searchItem.DataType = "string";
searchItem.MaxCount = -1;
searchItem.OrderBy = "";
// 帐户库不能去非用字
// return:
// -1 出错
// 0 成功
int nRet = db.SearchByUnion(searchItem,
null, //用于中断 , deleget
resultSet,
0,
out strError,
out strWarning);
if (nRet == -1)
return -1;
}
return 0;
}
// 获取指纹信息，追加到结果集文件的尾部
// parameters:
// update_table key为读者记录路径
static void AppendFingerprintInfo(
LibraryChannel channel,
DpResultSet resultset,
Hashtable update_table,
CancellationToken token)
{
List <string> lines = new List <string>();
foreach (string recpath in update_table.Keys)
{
lines.Add(recpath);
}
BrowseLoader loader = new BrowseLoader();
loader.RecPaths = lines;
loader.Channel = channel;
loader.Format = "id,cols,format:cfgs/browse_fingerprint";
loader.Prompt += Loader_Prompt;
foreach (DigitalPlatform.LibraryClient.localhost.Record record in loader)
{
token.ThrowIfCancellationRequested();
ShowMessage("追加 " + record.Path);
if (record.Cols == null || record.Cols.Length < 3)
{
string strError = "record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_fingerprint";
// TODO: 并发操作的情况下，会在中途出现读者记录被别的前端修改的情况，这里似乎可以continue
throw new Exception(strError);
}
// 如果证条码号为空，无法建立对照关系，要跳过
if (string.IsNullOrEmpty(record.Cols[1]) == true)
{
continue;
}
DpRecord item = new DpRecord(record.Path);
// timestamp | barcode | fingerprint
item.BrowseText = record.Cols[0] + "|" + record.Cols[1] + "|" + record.Cols[2];
resultset.Add(item);
}
#if NO
// 需要获得更新的事项，然后追加到结果集文件的尾部
// 注意，需要定期彻底重建结果集文件，以便回收多余空间
List <string> lines = new List <string>();
foreach (string recpath in update_table.Keys)
{
lines.Add(recpath);
if (lines.Count >= 100)
{
List <DigitalPlatform.LibraryClient.localhost.Record> records = null;
GetSomeFingerprintData(
channel,
lines,
token,
out records);
foreach (DigitalPlatform.LibraryClient.localhost.Record record in records)
{
if (record.Cols == null || record.Cols.Length < 3)
{
strError = "record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_fingerprint";
// TODO: 并发操作的情况下，会在中途出现读者记录被别的前端修改的情况，这里似乎可以continue
return(-1);
}
// 如果证条码号为空，无法建立对照关系，要跳过
if (string.IsNullOrEmpty(record.Cols[1]) == true)
{
continue;
}
DpRecord item = new DpRecord(record.Path);
// timestamp | barcode | fingerprint
item.BrowseText = record.Cols[0] + "|" + record.Cols[1] + "|" + record.Cols[2];
resultset.Add(item);
}
lines.Clear();
}
}
if (lines.Count > 0)
{
List <DigitalPlatform.LibraryClient.localhost.Record> records = null;
GetSomeFingerprintData(
channel,
lines,
token,
out records);
foreach (DigitalPlatform.LibraryClient.localhost.Record record in records)
{
if (record.Cols == null || record.Cols.Length < 3)
{
strError = "record.Cols error ... 有可能是因为读者库缺乏配置文件 cfgs/browse_fingerprint";
// TODO: 并发操作的情况下，会在中途出现读者记录被别的前端修改的情况，这里似乎可以continue
return(-1);
}
DpRecord item = new DpRecord(record.Path);
// timestamp | barcode | fingerprint
item.BrowseText = record.Cols[0] + "|" + record.Cols[1] + "|" + record.Cols[2];
resultset.Add(item);
}
}
return(0);
#endif
}
// 按ID检索记录
// parameter:
// searchItem SearchItem对象，包括检索信息
// isConnected 连接对象的delegate
// resultSet 结果集对象,存放命中记录
// return:
// -1 出错
// 0 成功
// 线：不安全
private int SearchByID(SearchItem searchItem,
ChannelHandle handle,
// Delegate_isConnected isConnected,
DpResultSet resultSet,
out string strError)
{
strError = "";
// 从库目录里得到所有似记录文件
string[] files = Directory.GetFiles(this.m_strSourceFullPath, "??????????.xml");
ArrayList records = new ArrayList();
foreach (string fileName in files)
{
FileInfo fileInfo = new FileInfo(fileName);
string strFileName = fileInfo.Name;
if (this.IsRecord(strFileName) == false)
continue;
records.Add(this.XmlFileName2RecordID(strFileName));
}
//前方一致
if (searchItem.Match == "left"
|| searchItem.Match == "")
{
foreach (string recordID in records)
{
if (recordID.Length < searchItem.Word.Length)
continue;
string strFirstPart = recordID.Substring(0,
searchItem.Word.Length);
if (strFirstPart == searchItem.Word)
{
string strRecPath = this.FullID + "/" + recordID;
resultSet.Add(new DpRecord(strRecPath));
}
}
}
else if (searchItem.Match == "exact")
{
// 从检索词时分析出来关系
if (searchItem.Relation == "draw"
|| searchItem.Relation == "range")
{
foreach (string recordID in records)
{
string strStartID;
string strEndID;
bool bRet = StringUtil.SplitRangeEx(searchItem.Word,
out strStartID,
out strEndID);
if (bRet == true)
{
strStartID = DbPath.GetID10(strStartID);
strEndID = DbPath.GetID10(strEndID);
if (String.Compare(recordID, strStartID, true) >= 0
&& String.Compare(recordID, strEndID, true) <= 0)
{
string strRecPath = this.FullID + "/" + recordID;
resultSet.Add(new DpRecord(strRecPath));
continue;
}
}
else
{
string strOperator;
string strCanKaoID;
StringUtil.GetPartCondition(searchItem.Word,
out strOperator,
out strCanKaoID);
strCanKaoID = DbPath.GetID10(strCanKaoID);
if (StringUtil.CompareByOperator(recordID,
strOperator,
strCanKaoID) == true)
{
string strRecPath = this.FullID + "/" + recordID;
resultSet.Add(new DpRecord(strRecPath));
continue;
}
}
}
}
else
{
foreach (string recordID in records)
{
searchItem.Word = DbPath.GetID10(searchItem.Word);
if (StringUtil.CompareByOperator(recordID,
searchItem.Relation,
searchItem.Word) == true)
{
string strRecPath = this.FullID + "/" + recordID;
resultSet.Add(new DpRecord(strRecPath));
continue;
}
}
}
}
return 0;
}
// 创建一个新的结果集对象，但并不进入容器管理范畴
public DpResultSet NewResultSet()
{
DpResultSet resultset = new DpResultSet(GetTempFileName);
Debug.Assert(string.IsNullOrEmpty(this.app.ResultsetDir) == false, "");
resultset.TempFileDir = this.app.ResultsetDir;
// resultset.GetTempFilename += new GetTempFilenameEventHandler(resultset_GetTempFilename);
return resultset;
}
// 检索
// parameters:
// searchItem SearchItem对象，存放检索词等信息
// isConnected 连接对象
// resultSet 结果集对象，存放命中记录
// strLang 语言版本，
// return:
// -1 出错
// 0 成功
internal override int SearchByUnion(SearchItem searchItem,
Delegate_isConnected isConnected,
DpResultSet resultSet,
int nWarningLevel,
out string strError,
out string strWarning)
{
strError = "";
strWarning = "";
//**********对数据库加读锁**************
m_lock.AcquireReaderLock(m_nTimeOut);
#if DEBUG_LOCK_SQLDATABASE
this.container.WriteDebugInfo("SearchByUnion()，对'" + this.GetCaption("zh-cn") + "'数据库加读锁。");
#endif
try
{
bool bHasID;
List<TableInfo> aTableInfo = null;
int nRet = this.TableNames2aTableInfo(searchItem.TargetTables,
out bHasID,
out aTableInfo,
out strError);
if (nRet == -1)
return -1;
if (bHasID == true)
{
nRet = SearchByID(searchItem,
isConnected,
resultSet,
out strError);
if (nRet == -1)
return -1;
}
// 对sql库来说,通过ID检索后，记录已排序，去重
if (aTableInfo == null || aTableInfo.Count == 0)
return 0;
string strCommand = "";
// Sql命令参数数组
List<SqlParameter> aSqlParameter = new List<SqlParameter>();
string strSelectKeystring = "";
if (searchItem.KeyOrder != "")
{
if (aTableInfo.Count > 1)
strSelectKeystring = ",keystring";
}
// 循环每一个检索途径
for (int i = 0; i < aTableInfo.Count; i++)
{
TableInfo tableInfo = aTableInfo[i];
// 参数名的后缀
string strPostfix = Convert.ToString(i);
string strConditionAboutKey = "";
try
{
nRet = GetKeyCondition(
searchItem,
tableInfo.nodeConvertQueryString,
tableInfo.nodeConvertQueryNumber,
strPostfix,
ref aSqlParameter,
out strConditionAboutKey,
out strError);
if (nRet == -1)
return -1;
}
catch (NoMatchException ex)
{
strWarning = ex.Message;
strError = strWarning;
return -1;
}
// 如果限制了一个最大数，则按每个途径都是这个最大数算
string strTop = "";
if (searchItem.MaxCount != -1) //限制的最大数
strTop = " TOP " + Convert.ToString(searchItem.MaxCount) + " ";
string strWhere = "";
if (strConditionAboutKey != "")
strWhere = " WHERE " + strConditionAboutKey;
string strOneCommand = "";
if (i == 0)// 第一个表
{
strOneCommand = "use " + this.m_strSqlDbName + " "
+ " SELECT "
+ " DISTINCT "
+ strTop
+ " idstring" + strSelectKeystring + " "
+ " FROM " + tableInfo.SqlTableName + " "
+ strWhere;
}
else
{
strOneCommand = " union SELECT "
+ " DISTINCT "
+ strTop
+ " idstring" + strSelectKeystring + " " //DISTINCT 去重
+ " FROM " + tableInfo.SqlTableName + " "
+ strWhere;
}
strCommand += strOneCommand;
}
string strOrderBy = "";
if (searchItem.OrderBy != "")
strOrderBy = "ORDER BY " + searchItem.OrderBy + " ";
strCommand += strOrderBy;
strCommand += " use master " + "\n";
if (aSqlParameter == null)
{
strError = "一个参数也没是不可能的情况";
return -1;
}
SqlCommand command = null;
SqlConnection connection = new SqlConnection(this.m_strConnString);
connection.Open();
try
{
command = new SqlCommand(strCommand,
connection);
foreach (SqlParameter sqlParameter in aSqlParameter)
{
command.Parameters.Add(sqlParameter);
}
command.CommandTimeout = 20 * 60; // 把检索时间变大
// 调新线程处理
DatabaseCommandTask task = new DatabaseCommandTask(command);
try
{
if (task == null)
{
strError = "test为null";
return -1;
}
Thread t1 = new Thread(new ThreadStart(task.ThreadMain));
t1.Start();
bool bRet;
while (true)
{
if (isConnected != null)
{
if (isConnected() == false)
{
strError = "用户中断";
return -1;
}
}
bRet = task.m_event.WaitOne(100, false); //1/10秒看一次
if (bRet == true)
break;
}
if (task.DataReader == null
|| task.DataReader.HasRows == false)
{
return 0;
}
int nGetedCount = 0;
while (task.DataReader.Read())
{
if (isConnected != null
&& (nGetedCount % 10000) == 0)
{
if (isConnected() == false)
{
strError = "用户中断";
return -1;
}
}
string strId = this.FullID + "/" + (string)task.DataReader[0]; // 记录格式为：库id/记录号
resultSet.Add(new DpRecord(strId));
nGetedCount++;
// 超过最大数了
if (searchItem.MaxCount != -1
&& nGetedCount >= searchItem.MaxCount)
break;
Thread.Sleep(0);
}
}
finally
{
if (task.DataReader != null)
task.DataReader.Close();
}
}
catch (SqlException sqlEx)
{
if (sqlEx.Errors is SqlErrorCollection)
strError = "数据库'" + this.GetCaption("zh") + "'尚未初始化。";
else
strError = sqlEx.Message;
return -1;
}
catch (Exception ex)
{
strError = ex.Message;
return -1;
}
finally // 连接
{
connection.Close();
}
}
catch (Exception ex)
{
strError = ex.Message;
return -1;
}
finally
{
//*****************对数据库解读锁***************
m_lock.ReleaseReaderLock();
#if DEBUG_LOCK_SQLDATABASE
this.container.WriteDebugInfo("SearchByUnion()，对'" + this.GetCaption("zh-cn") + "'数据库解读锁。");
#endif
}
return 0;
}
// 从结果集中提取指定范围的记录
// parameter:
// lStart 开始序号
// lLength 长度. -1表示从lStart到末尾
// strLang 语言
// strStyle 样式,以逗号分隔，id:表示取id,cols表示取浏览格式
// 如果包含 format:cfgs/browse 这样的子串，表示指定浏览格式
// aRecord 得到的记录数组，成员为类型为Record
// strError out参数，返回出错信息
// result:
// -1 出错
// >=0 结果集的总数
public long API_GetRecords(
DpResultSet resultSet,
long lStart,
long lLength,
string strLang,
string strStyle,
out Record[] records,
out string strError)
{
records = null;
strError = "";
// DpResultSet resultSet = this.DefaultResultSet;
if (resultSet == null)
{
strError = "GetRecords()出错, resultSet 为 null";
return -1;
}
long lTotalPackageLength = 0; // 累计计算要输出的XML记录占据的空间
long lOutputLength;
// 检查lStart lLength和resultset.Count之间的关系,
// 和每批返回最大元素数限制, 综合得出一个合适的尺寸
// return:
// -1 出错
// 0 成功
int nRet = ConvertUtil.GetRealLength((int)lStart,
(int)lLength,
(int)resultSet.Count,
SessionInfo.MaxRecordsCountPerApi,//nMaxCount,
out lOutputLength,
out strError);
if (nRet == -1)
return -1;
bool bKeyCount = StringUtil.IsInList("keycount", strStyle, true);
bool bKeyID = StringUtil.IsInList("keyid", strStyle, true);
bool bHasID = StringUtil.IsInList("id", strStyle, true);
bool bHasCols = StringUtil.IsInList("cols", strStyle, true);
bool bHasKey = StringUtil.IsInList("key", strStyle, true);
if (bKeyID == true
&& bHasID == false && bHasCols == false && bHasKey == false)
{
strError = "strStyle包含了keyid但是没有包含id/key/cols中任何一个，导致API不返回任何内容，操作无意义";
return -1;
}
bool bXml = StringUtil.IsInList("xml", strStyle, true);
bool bWithResMetadata = StringUtil.IsInList("withresmetadata", strStyle, true);
bool bTimestamp = StringUtil.IsInList("timestamp", strStyle, true);
bool bMetadata = StringUtil.IsInList("metadata", strStyle, true);
string strFormat = StringUtil.GetStyleParam(strStyle, "format");
List<Record> results = new List<Record>(100);
long lPos = -1; // 中间保持不透明的值
for (long i = 0; i < lOutputLength; i++)
{
DpRecord dpRecord = null;
long lIndex = lStart + i;
if (lIndex == lStart)
{
dpRecord = resultSet.GetFirstRecord(
lIndex,
false,
out lPos);
}
else
{
// 取元素比[]操作速度快
dpRecord = resultSet.GetNextRecord(
ref lPos);
}
if (dpRecord == null)
break;
Record record = new Record();
if (bKeyCount == true)
{
record.Path = dpRecord.ID;
record.Cols = new string[1];
record.Cols[0] = dpRecord.Index.ToString();
#if NO
lTotalPackageLength += record.Path.Length;
lTotalPackageLength += record.Cols[0].Length;
if (lTotalPackageLength > QUOTA_SIZE
&& i > 0)
{
// 响应包的尺寸已经超过 1M，并且已经至少包含了一条记录
break;
}
#endif
goto CONTINUE;
}
DbPath path = new DbPath(dpRecord.ID);
Database db = this.app.Dbs.GetDatabaseSafety(path.Name);
if (db == null)
{
strError = "GetDatabaseSafety()从库id '" + path.Name + "' 找数据库对象失败";
return -1;
}
// 如果有必要获得记录体
string strXml = "";
string strMetadata = "";
byte[] baTimestamp = null;
if (bXml == true || bTimestamp == true || bMetadata == true)
{
// 获得一条记录的 XML 字符串
// return:
// -1 出错
// -4 未找到记录
// -10 记录局部未找到
// 0 成功
long lRet = GetXmlBody(
db,
path.ID,
bXml,
bTimestamp,
bMetadata,
bWithResMetadata,
out strXml,
out strMetadata,
out baTimestamp,
out strError);
if (lRet <= -1)
{
record.RecordBody = new RecordBody();
record.RecordBody.Xml = strXml;
record.RecordBody.Metadata = strMetadata;
record.RecordBody.Timestamp = baTimestamp;
Result result = new Result();
result.Value = -1;
result.ErrorCode = KernelApplication.Ret2ErrorCode((int)lRet);
result.ErrorString = strError;
record.RecordBody.Result = result;
goto CONTINUE;
// return lRet;
}
#if NO
lTotalPackageLength += strXml.Length;
if (string.IsNullOrEmpty(strMetadata) == false)
lTotalPackageLength += strMetadata.Length;
if (baTimestamp != null)
lTotalPackageLength += baTimestamp.Length * 2;
if (lTotalPackageLength > QUOTA_SIZE
&& i > 0)
{
// 响应包的尺寸已经超过 1M，并且已经至少包含了一条记录
break;
}
#endif
record.RecordBody = new RecordBody();
record.RecordBody.Xml = strXml;
record.RecordBody.Metadata = strMetadata;
record.RecordBody.Timestamp = baTimestamp;
}
if (bKeyID == true)
{
// string strID = "";
string strKey = "";
// strID = dpRecord.ID;
strKey = dpRecord.BrowseText;
/*
string strText = dpRecord.ID;
nRet = strText.LastIndexOf(",");
if (nRet != -1)
{
strKey = strText.Substring(0, nRet);
strID = strText.Substring(nRet + 1);
}
else
strID = strText;
* */
if (bHasID == true)
{
// GetCaptionSafety()函数先找到指定语言的库名;
// 如果没有找到,就找截短形态的语言的库名;
// 再找不到,就用第一种语言的库名。
// 如果连一种语言也没有，则返回库id
record.Path = db.GetCaptionSafety(strLang) + "/" + path.CompressedID;
// lTotalPackageLength += record.Path.Length;
}
if (bHasKey == true)
{
record.Keys = BuildKeyFromArray(strKey);
// lTotalPackageLength += GetLength(record.Keys);
}
if (bHasCols == true)
{
string[] cols;
nRet = db.GetCols(
strFormat,
path.ID10,
strXml,
0,
out cols);
// 2013/1/14
if (nRet == -1)
{
if (cols != null && cols.Length > 0)
strError = cols[0];
else
strError = "GetCols() error";
return -1;
}
record.Cols = cols;
// lTotalPackageLength += nRet;
}
goto CONTINUE;
}
{
if (bHasID == true)
{
// GetCaptionSafety()函数先找到指定语言的库名;
// 如果没有找到,就找截短形态的语言的库名;
// 再找不到,就用第一种语言的库名。
// 如果连一种语言也没有，则返回库id
record.Path = db.GetCaptionSafety(strLang) + "/" + path.CompressedID;
// lTotalPackageLength += record.Path.Length;
}
// 在不是keyid的风格下(例如keycount，空)，cols全部是浏览列
if (bHasCols == true)
{
string[] cols;
nRet = db.GetCols(
strFormat,
path.ID10,
strXml,
0,
out cols);
// 2013/1/14
if (nRet == -1)
{
if (cols != null && cols.Length > 0)
strError = cols[0];
else
strError = "GetCols() error";
return -1;
}
record.Cols = cols;
// lTotalPackageLength += nRet;
}
}
CONTINUE:
lTotalPackageLength += GetLength(record);
if (lTotalPackageLength > QUOTA_SIZE
&& i > 0)
{
// 响应包的尺寸已经超过 1M，并且已经至少包含了一条记录
break;
}
// records[i] = record;
results.Add(record);
Thread.Sleep(0); // 降低CPU耗用?
}
records = new Record[results.Count];
results.CopyTo(records);
return resultSet.Count;
}
// 按ID检索记录
// parameter:
// searchItem SearchItem对象，包括检索信息
// isConnected 连接对象的delegate
// resultSet 结果集对象,存放命中记录
// return:
// -1 出错
// 0 成功
// 线：不安全
private int SearchByID(SearchItem searchItem,
Delegate_isConnected isConnected,
DpResultSet resultSet,
out string strError)
{
strError = "";
Debug.Assert(searchItem != null, "SearchByID()调用错误，searchItem参数值不能为null。");
Debug.Assert(isConnected != null, "SearchByID()调用错误，isConnected参数值不能为null。");
Debug.Assert(resultSet != null, "SearchByID()调用错误，resultSet参数值不能为null。");
SqlConnection connection = new SqlConnection(this.m_strConnString);
connection.Open();
try
{
List<SqlParameter> aSqlParameter = new List<SqlParameter>();
string strWhere = "";
if (searchItem.Match == "left"
|| searchItem.Match == "")
{
strWhere = " WHERE id LIKE @id and id like N'[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]' ";
SqlParameter temp = new SqlParameter("@id", SqlDbType.NVarChar);
temp.Value = searchItem.Word + "%";
aSqlParameter.Add(temp);
}
else if (searchItem.Match == "middle")
{
strWhere = " WHERE id LIKE @id and id like N'[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]' ";
SqlParameter temp = new SqlParameter("@id", SqlDbType.NVarChar);
temp.Value = "%" + searchItem.Word + "%";
aSqlParameter.Add(temp);
}
else if (searchItem.Match == "right")
{
strWhere = " WHERE id LIKE @id and id like N'[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]' ";
SqlParameter temp = new SqlParameter("@id", SqlDbType.NVarChar);
temp.Value = "%" + searchItem.Word;
aSqlParameter.Add(temp);
}
else if (searchItem.Match == "exact")
{
if (searchItem.DataType == "string")
searchItem.Word = DbPath.GetID10(searchItem.Word);
if (searchItem.Relation == "draw")
{
int nPosition;
nPosition = searchItem.Word.IndexOf("-");
if (nPosition >= 0)
{
string strStartID;
string strEndID;
StringUtil.SplitRange(searchItem.Word,
out strStartID,
out strEndID);
strStartID = DbPath.GetID10(strStartID);
strEndID = DbPath.GetID10(strEndID);
strWhere = " WHERE @idMin <=id and id<= @idMax and id like N'[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]' ";
SqlParameter temp = new SqlParameter("@idMin", SqlDbType.NVarChar);
temp.Value = strStartID;
aSqlParameter.Add(temp);
temp = new SqlParameter("@idMax", SqlDbType.NVarChar);
temp.Value = strEndID;
aSqlParameter.Add(temp);
}
else
{
string strOperator;
string strRealText;
StringUtil.GetPartCondition(searchItem.Word,
out strOperator,
out strRealText);
strRealText = DbPath.GetID10(strRealText);
strWhere = " WHERE id " + strOperator + " @id and id like N'[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]' ";
SqlParameter temp = new SqlParameter("@id", SqlDbType.NVarChar);
temp.Value = strRealText;
aSqlParameter.Add(temp);
}
}
else
{
searchItem.Word = DbPath.GetID10(searchItem.Word);
strWhere = " WHERE id " + searchItem.Relation + " @id and id like N'[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]' ";
SqlParameter temp = new SqlParameter("@id", SqlDbType.NVarChar);
temp.Value = searchItem.Word;
aSqlParameter.Add(temp);
}
}
string strTop = "";
if (searchItem.MaxCount != -1) // 只命中指定的条数
strTop = " TOP " + Convert.ToString(searchItem.MaxCount) + " ";
string strOrderBy = "";
if (searchItem.IdOrder != "")
strOrderBy = "ORDER BY id " + searchItem.IdOrder + " ";
string strCommand = "use " + this.m_strSqlDbName
+ " SELECT "
+ " DISTINCT "
+ strTop
+ " id "
+ " FROM records "
+ strWhere
+ " " + strOrderBy + "\n";
strCommand += " use master " + "\n";
SqlCommand command = new SqlCommand(strCommand, connection);
command.CommandTimeout = 20 * 60; // 把检索时间变大
foreach (SqlParameter sqlParameter in aSqlParameter)
{
command.Parameters.Add(sqlParameter);
}
DatabaseCommandTask task =
new DatabaseCommandTask(command);
try
{
Thread t1 = new Thread(new ThreadStart(task.ThreadMain));
t1.Start();
bool bRet;
while (true)
{
if (isConnected != null) //只是不再检索了
{
if (isConnected() == false)
{
strError = "用户中断";
return -1;
}
}
bRet = task.m_event.WaitOne(100, false); //millisecondsTimeout
if (bRet == true)
break;
}
if (task.bError == true)
{
strError = task.ErrorString;
return -1;
}
if (task.DataReader == null)
return 0;
if (task.DataReader.HasRows == false)
{
return 0;
}
int nLoopCount = 0;
while (task.DataReader.Read())
{
if (nLoopCount % 10000 == 0)
{
if (isConnected != null)
{
if (isConnected() == false)
{
strError = "用户中断";
return -1;
}
}
}
string strID = ((string)task.DataReader[0]);
if (strID.Length != 10)
{
strError = "结果集中出现了长度不是10位的记录号，不正常";
return -1;
}
string strId = this.FullID + "/" + strID; //记录路径格式：库ID/记录号
resultSet.Add(new DpRecord(strId));
nLoopCount++;
Thread.Sleep(0);
}
}
finally
{
if (task != null && task.DataReader != null)
task.DataReader.Close();
}
}
catch (SqlException sqlEx)
{
if (sqlEx.Errors is SqlErrorCollection)
strError = "数据库'" + this.GetCaption("zh") + "'尚未初始化。";
else
strError = sqlEx.Message;
return -1;
}
catch (Exception ex)
{
strError = ex.Message;
return -1;
}
finally // 连接
{
connection.Close();
}
return 0;
}
void export_Click(object sender, EventArgs e)
{
string strError = "";
int nRet = 0;
OpacApplication app = (OpacApplication)this.Page.Application["app"];
SessionInfo sessioninfo = (SessionInfo)this.Page.Session["sessioninfo"];
RadioButton iso2709 = (RadioButton)this.FindControl("iso2709");
RadioButton pathfile = (RadioButton)this.FindControl("pathfile");
RadioButton gb2312 = (RadioButton)this.FindControl("gb2312");
RadioButton utf8 = (RadioButton)this.FindControl("utf8");
RadioButton selected = (RadioButton)this.FindControl("selected");
RadioButton all = (RadioButton)this.FindControl("all");
List<string> paths = null;
// 检查是否允许导出 MARC 文件
if (pathfile.Checked == false)
{
bool bAllowExportMarc = this.AllowExportMarc;
if (bAllowExportMarc == false)
{
strError = "当前系统不允许导出 MARC 文件";
goto ERROR1;
}
}
LibraryChannel channel = sessioninfo.GetChannel(true);
try
{
// 如果都没有选，则认selected items
if (all.Checked == false)
{
paths = this.GetCheckedPath();
if (paths.Count == 0)
{
strError = "尚未选择要导出的事项";
goto ERROR1;
}
}
else
{
if (this.AllowExportAllMarc == false)
{
strError = "不允许导出结果集的全部记录";
goto ERROR1;
}
paths = new List<string>();
string strResultsetFilename = this.ResultsetFilename;
if (String.IsNullOrEmpty(strResultsetFilename) == false)
{
app.ResultsetLocks.LockForRead(strResultsetFilename, 500);
try
{
DpResultSet resultset = new DpResultSet(false, false);
try
{
resultset.Attach(this.ResultsetFilename,
this.ResultsetFilename + ".index");
}
catch (Exception ex)
{
this.SetErrorInfo(ex.Message); // 显示出错信息
goto ERROR1;
}
try
{
for (int i = 0; i < resultset.Count; i++)
{
Thread.Sleep(1);
if (this.Page.Response.IsClientConnected == false)
{
strError = "中断";
goto ERROR1;
}
paths.Add(resultset[i].ID);
}
}
finally
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1, out strTemp2);
}
}
finally
{
app.ResultsetLocks.UnlockForRead(strResultsetFilename);
}
}
else
{
Record[] records = null;
long lStart = 0;
for (; ; )
{
Thread.Sleep(1);
if (this.Page.Response.IsClientConnected == false)
{
strError = "中断";
goto ERROR1;
}
long lRet = // sessioninfo.Channel.
channel.GetSearchResult(
null,
this.ResultSetName,
lStart,
100,
"id",
this.Lang,
out records,
out strError);
if (lRet == -1)
{
strError = "获得结果集时出错: " + strError;
goto ERROR1;
}
for (int i = 0; i < records.Length; i++)
{
paths.Add(records[i].Path);
}
lStart += records.Length;
if (lStart >= lRet)
break;
}
}
if (paths.Count == 0)
{
strError = "结果集为空，放弃导出";
goto ERROR1;
}
}
// 不让浏览器缓存页面
this.Page.Response.AddHeader("Pragma", "no-cache");
this.Page.Response.AddHeader("Cache-Control", "no-store, no-cache, must-revalidate, post-check=0, pre-check=0");
this.Page.Response.AddHeader("Expires", "0");
if (pathfile.Checked == false)
{
// ISO2709文件
this.Page.Response.ContentType = "application/iso2709";
string strEncodedFileName = HttpUtility.UrlEncode("书目.mrc", Encoding.UTF8);
this.Page.Response.AddHeader("content-disposition", "attachment; filename=" + strEncodedFileName);
Encoding targetEncoding = null;
// 如果都没有选，则认utf-8
if (gb2312.Checked == true)
{
targetEncoding = Encoding.GetEncoding(936);
this.Page.Response.Charset = "gb2312";
}
else
{
targetEncoding = Encoding.UTF8;
this.Page.Response.Charset = "utf-8";
}
for (int i = 0; i < paths.Count; i++)
{
if (this.Page.Response.IsClientConnected == false)
break;
string strPath = paths[i];
string strDbName = StringUtil.GetDbName(strPath);
if (app.IsBiblioDbName(strDbName) == false)
continue;
string[] formats = new string[1];
formats[0] = "xml";
string[] results = null;
byte[] timestamp = null;
long lRet = // sessioninfo.Channel.
channel.GetBiblioInfos(
null,
strPath,
"",
formats,
out results,
out timestamp,
out strError);
if (lRet == -1)
{
strError = "获得书目记录 '" + strPath + "' 时发生错误: " + strError;
goto ERROR1;
}
if (lRet == 0)
continue;
if (results == null || results.Length < 1)
{
strError = "results error {837C0AC5-F257-45F6-BABC-1495F5243D85}";
goto ERROR1;
}
string strXml = results[0];
// 将XML书目记录转换为MARC格式
string strMarc = "";
string strOutMarcSyntax = "";
// 将MARCXML格式的xml记录转换为marc机内格式字符串
// parameters:
// bWarning ==true, 警告后继续转换,不严格对待错误; = false, 非常严格对待错误,遇到错误后不继续转换
// strMarcSyntax 指示marc语法,如果==""，则自动识别
// strOutMarcSyntax out参数，返回marc，如果strMarcSyntax == ""，返回找到marc语法，否则返回与输入参数strMarcSyntax相同的值
nRet = MarcUtil.Xml2Marc(strXml,
false,
"", // strMarcSyntax
out strOutMarcSyntax,
out strMarc,
out strError);
if (nRet == -1)
{
strError = "记录从XML格式转换为MARC格式时出错: " + strError;
goto ERROR1;
}
byte[] baResult = null;
// 将MARC机内格式转换为ISO2709格式
// parameters:
// strSourceMARC [in]机内格式MARC记录。
// strMarcSyntax [in]为"unimarc"或"usmarc"
// targetEncoding [in]输出ISO2709的编码方式。为UTF8、codepage-936等等
// baResult [out]输出的ISO2709记录。编码方式受targetEncoding参数控制。注意，缓冲区末尾不包含0字符。
// return:
// -1 出错
// 0 成功
nRet = MarcUtil.CvtJineiToISO2709(
strMarc,
strOutMarcSyntax,
targetEncoding,
out baResult,
out strError);
if (nRet == -1)
{
strError = "将MARC字符串转换为ISO2709记录时出错: " + strError;
goto ERROR1;
}
this.Page.Response.OutputStream.Write(baResult, 0, baResult.Length);
}
}
else
{
// 记录路径文件
this.Page.Response.ContentType = "text/recpath";
string strEncodedFileName = HttpUtility.UrlEncode("记录路径.txt", Encoding.UTF8);
this.Page.Response.AddHeader("content-disposition", "attachment; filename=" + strEncodedFileName);
this.Page.Response.Charset = "utf-8";
for (int i = 0; i < paths.Count; i++)
{
if (this.Page.Response.IsClientConnected == false)
break;
string strPath = paths[i];
byte[] baResult = Encoding.UTF8.GetBytes(strPath + (i < paths.Count - 1 ? "\r\n" : ""));
this.Page.Response.OutputStream.Write(baResult, 0, baResult.Length);
}
}
this.Page.Response.End();
return;
}
finally
{
sessioninfo.ReturnChannel(channel);
}
ERROR1:
this.Page.Response.ContentType = "text/html";
this.Page.Response.Charset = "utf-8";
this.SetDebugInfo("errorinfo", strError);
}
// 创建一个馆藏地的限定结果集
void CreateOneLocationResultset(string strLocation)
{
string strError = "";
// 临时的SessionInfo对象
SessionInfo session = new SessionInfo(this);
try
{
string strQueryXml = "";
// 构造检索实体库的 XML 检索式
// return:
// -1 出错
// 0 没有发现任何实体库定义
// 1 成功
int nRet = this.BuildSearchItemQuery(
"<全部>",
strLocation + "/",
-1,
"馆藏地点",
"left",
"zh",
"", // strSearchStyle,
out strQueryXml,
out strError);
if (nRet == -1)
goto ERROR1;
if (nRet == 0)
return;
this._app_down.Token.ThrowIfCancellationRequested();
RmsChannel channel = session.Channels.GetChannel(this.WsUrl);
if (channel == null)
{
strError = "get channel error";
goto ERROR1;
}
#if DETAIL_LOG
this.WriteErrorLog("开始检索");
#endif
long lHitCount = channel.DoSearch(strQueryXml,
"default",
"", // strOutputStyle,
out strError);
if (lHitCount == -1)
goto ERROR1;
if (lHitCount == 0)
{
// 没有命中任何记录，也要继续后面的处理
}
this._app_down.Token.ThrowIfCancellationRequested();
DpResultSet resultset = new DpResultSet(true);
try
{
if (lHitCount > 0)
{
nRet = GetResultset(channel,
"default",
resultset,
out strError);
if (nRet == -1)
goto ERROR1;
}
// 写入 dp2kernel 成为永久结果集
nRet = UploadPermanentResultset(channel,
strLocation,
resultset,
out strError);
if (nRet == -1)
goto ERROR1;
}
finally
{
resultset.Close();
}
return;
}
finally
{
session.CloseSession();
session = null;
}
ERROR1:
this.WriteErrorLog("馆藏地结果集创建出错: " + strError);
return;
}
// 检索
// parameter:
// strOutpuStyle 输出的风格。如果为keycount，则输出归并统计后的key+count；否则，或者缺省，为传统的输出记录id
// searchItem SearchItem对象
// isConnected IsConnection对象，用于判断通讯是否连接
// resultSet 结果集对象，存放命中记录。本函数并不在检索前清空结果集，因此，对同一结果集对象多次执行本函数，则可以把命中结果追加在一起
// nWarningLevel 处理警告级别 0：表示特别强烈，出现警告也当作出错；1：表示不强烈，不返回出错，继续执行
// strError out参数，返回出错信息
// strWarning out参数，返回警告信息
// return:
// -1 出错
// >=0 命中记录数
// 线: 安全的
internal virtual int SearchByUnion(
string strOutputStyle,
SearchItem searchItem,
ChannelHandle handle,
// Delegate_isConnected isConnected,
DpResultSet resultSet,
int nWarningLevel,
out string strError,
out string strWarning)
{
strError = "";
strWarning = "";
return 0;
}
const int _upload_batchSize = 1000; // 上传结果集每批个数
// 写入 dp2kernel 成为永久结果集
int UploadPermanentResultset(RmsChannel channel,
string strResultsetName,
DpResultSet resultset,
out string strError)
{
strError = "";
// resultset.Clear(); // testing
List<RecordBody> records = new List<RecordBody>();
// 结果集为空，也要在 dp2kernel 端创建一个结果集对象
if (resultset.Count == 0)
{
RecordBody[] results = null;
long lRet = channel.DoWriteRecords(null,
records.ToArray(),
"createResultset,name:#" + strResultsetName + ",clear,permanent",
out results,
out strError);
if (lRet == -1)
return -1;
return 0;
}
#if DETAIL_LOG
this.WriteErrorLog("开始上传结果集到 dp2kernel");
#endif
long lPos = -1; // 中间保持不透明的值
bool bFirst = true;
for (long i = 0; i < resultset.Count; i++)
{
DpRecord dpRecord = null;
long lIndex = i;
if (lIndex == 0)
{
dpRecord = resultset.GetFirstRecord(
lIndex,
false,
out lPos);
}
else
{
// 取元素比[]操作速度快
dpRecord = resultset.GetNextRecord(
ref lPos);
}
if (dpRecord == null)
break;
RecordBody record = new RecordBody();
record.Path = dpRecord.ID;
records.Add(record);
if (records.Count >= _upload_batchSize || (i >= resultset.Count - 1 && records.Count > 0))
{
this._app_down.Token.ThrowIfCancellationRequested();
#if DETAIL_LOG
this.WriteErrorLog("一批 " + records.Count);
#endif
RecordBody[] results = null;
long lRet = channel.DoWriteRecords(null,
records.ToArray(),
"createResultset,name:#~" + strResultsetName + (bFirst ? ",clear" : ""),
out results,
out strError);
if (lRet == -1)
return -1;
bFirst = false;
records.Clear();
}
}
// 最后一次执行改名、排序
{
RecordBody[] results = null;
long lRet = channel.DoWriteRecords(null,
null,
"renameResultset,oldname:#~" + strResultsetName + ",newname:#" + strResultsetName + ",permanent,sort",
out results,
out strError);
if (lRet == -1)
return -1;
}
#if DETAIL_LOG
this.WriteErrorLog("结束上传结果集");
#endif
return 0;
}
static int EnsureSorted(DpResultSet resultset,
ChannelHandle handle,
out string strError)
{
strError = "";
resultset.EnsureCreateIndex(); // 确保创建了索引
if (resultset.Sorted == false)
{
if (DoSort(resultset, handle/*isConnected*/) == true)
{
strError = "前端中断";
return -1;
}
Debug.Assert(resultset.Sorted == true, "");
}
return 0;
}
const int _removeDup_batchSize = 10000; // 利用 hashtable 进行局部去重的每批个数
// 从 dp2Kernel 端获取结果集
// parameters:
// strStyle tobibliorecpath 将实体\期\订购\评注 记录路径转换为书目记录路径,并去重
int GetResultset(RmsChannel channel,
string strResultsetName,
DpResultSet resultset,
out string strError)
{
strError = "";
m_biblioDbNameTable.Clear();
Hashtable temp_table = new Hashtable();
string strFormat = "id,cols,format:@coldef://parent"; // "id,xml";
SearchResultLoader loader = new SearchResultLoader(channel,
null,
strResultsetName,
strFormat);
loader.ElementType = "Record";
#if DETAIL_LOG
this.WriteErrorLog("开始从 dp2kernel 获取结果集");
#endif
int hashtable_removedup_loops = 0; // 利用 hashtable 去重的轮次。如果只有一轮，则可以免去最后的结果集文件去重
try
{
foreach (Record rec in loader)
{
this._app_down.Token.ThrowIfCancellationRequested();
{
if (rec.RecordBody != null
&& rec.RecordBody.Result != null
&& rec.RecordBody.Result.ErrorCode != ErrorCodeValue.NoError)
{
#if NO
strError = "获得结果集位置偏移 " + (lStart + j).ToString() + " 时出错，该记录已被忽略: " + rec.RecordBody.Result.ErrorString;
this.AppendResultText(strError + "\r\n");
#endif
continue;
}
string strBiblioRecPath = "";
#if NO
// 从册记录XML中获得书目记录路径
// return:
// -1 出错
// 1 成功
int nRet = GetBiblioRecPath(
rec.Path,
rec.RecordBody.Xml,
out strBiblioRecPath,
out strError);
if (nRet == -1)
return -1;
#endif
if (rec.Cols == null || rec.Cols.Length == 0)
{
#if NO
strError = "获得结果集位置偏移 " + (lStart + j).ToString() + " 时出错： rec.Cols 为空";
this.AppendResultText(strError + "\r\n");
#endif
continue;
}
// return:
// -1 出错
// 1 成功
int nRet = GetBiblioRecPathByParentID(
rec.Path,
rec.Cols[0],
out strBiblioRecPath,
out strError);
if (nRet == -1)
return -1;
// 缓冲并局部去重。局部去重可以减轻后面全局去重的压力
if (temp_table.Contains(strBiblioRecPath) == false)
{
temp_table.Add(strBiblioRecPath, null);
if (temp_table.Count > _removeDup_batchSize)
{
FlushTable(temp_table, resultset);
temp_table.Clear();
hashtable_removedup_loops++;
}
}
//DpRecord record = new DpRecord(rec.Path);
//item_paths.Add(record);
}
}
}
catch (Exception ex)
{
strError = ex.Message;
return -1;
}
// if (bToBiblioRecPath == true)
{
// 最后一批
if (temp_table.Count > 0)
{
FlushTable(temp_table, resultset);
temp_table.Clear();
hashtable_removedup_loops++;
}
resultset.Idle += new IdleEventHandler(biblio_paths_Idle); // 2016/1/23 原来这里是 -=，令人费解
try
{
#if DETAIL_LOG
this.WriteErrorLog("开始排序结果集, count=" + resultset.Count);
#endif
// 归并后写入结果集文件
resultset.QuickSort();
resultset.Sorted = true;
if (hashtable_removedup_loops > 1)
{
// 全局去重
#if DETAIL_LOG
this.WriteErrorLog("开始对结果集去重, count=" + resultset.Count);
#endif
resultset.RemoveDup();
#if DETAIL_LOG
this.WriteErrorLog("结束对结果集去重, count=" + resultset.Count);
#endif
}
}
finally
{
resultset.Idle -= new IdleEventHandler(biblio_paths_Idle);
}
}
return 0;
}
// 从结果集中提取指定范围的记录
// parameter:
// lStart 开始序号
// lLength 长度. -1表示从lStart到末尾
// strLang 语言
// strStyle 样式,以逗号分隔，id:表示取id,cols表示取浏览格式
// 如果包含 format:cfgs/browse 这样的子串，表示指定浏览格式
// aRecord 得到的记录数组，成员为类型为Record
// strError out参数，返回出错信息
// result:
// -1 出错
// >=0 结果集的总数
public long API_GetRecords(
DpResultSet resultSet,
long lStart,
long lLength,
string strLang,
string strStyle,
out Record[] records,
out string strError)
{
records = null;
strError = "";
// DpResultSet resultSet = this.DefaultResultSet;
if (resultSet == null)
{
strError = "GetRecords()出错, resultSet 为 null";
return(-1);
}
long lTotalPackageLength = 0; // 累计计算要输出的XML记录占据的空间
long lOutputLength;
// 检查lStart lLength和resultset.Count之间的关系,
// 和每批返回最大元素数限制, 综合得出一个合适的尺寸
// return:
// -1 出错
// 0 成功
int nRet = ConvertUtil.GetRealLength((int)lStart,
(int)lLength,
(int)resultSet.Count,
SessionInfo.MaxRecordsCountPerApi,//nMaxCount,
out lOutputLength,
out strError);
if (nRet == -1)
{
return(-1);
}
bool bKeyCount = StringUtil.IsInList("keycount", strStyle, true);
bool bKeyID = StringUtil.IsInList("keyid", strStyle, true);
bool bHasID = StringUtil.IsInList("id", strStyle, true);
bool bHasCols = StringUtil.IsInList("cols", strStyle, true);
bool bHasKey = StringUtil.IsInList("key", strStyle, true);
if (bKeyID == true &&
bHasID == false && bHasCols == false && bHasKey == false)
{
strError = "strStyle包含了keyid但是没有包含id/key/cols中任何一个，导致API不返回任何内容，操作无意义";
return(-1);
}
bool bXml = StringUtil.IsInList("xml", strStyle, true);
bool bWithResMetadata = StringUtil.IsInList("withresmetadata", strStyle, true);
bool bTimestamp = StringUtil.IsInList("timestamp", strStyle, true);
bool bMetadata = StringUtil.IsInList("metadata", strStyle, true);
string strFormat = StringUtil.GetStyleParam(strStyle, "format");
List <Record> results = new List <Record>(100);
long lPos = -1; // 中间保持不透明的值
for (long i = 0; i < lOutputLength; i++)
{
DpRecord dpRecord = null;
long lIndex = lStart + i;
if (lIndex == lStart)
{
dpRecord = resultSet.GetFirstRecord(
lIndex,
false,
out lPos);
}
else
{
// 取元素比[]操作速度快
dpRecord = resultSet.GetNextRecord(
ref lPos);
}
if (dpRecord == null)
{
break;
}
Record record = new Record();
if (bKeyCount == true)
{
record.Path = dpRecord.ID;
record.Cols = new string[1];
record.Cols[0] = dpRecord.Index.ToString();
#if NO
lTotalPackageLength += record.Path.Length;
lTotalPackageLength += record.Cols[0].Length;
if (lTotalPackageLength > QUOTA_SIZE &&
i > 0)
{
// 响应包的尺寸已经超过 1M，并且已经至少包含了一条记录
break;
}
#endif
goto CONTINUE;
}
DbPath path = new DbPath(dpRecord.ID);
Database db = this.app.Dbs.GetDatabaseSafety(path.Name);
if (db == null)
{
strError = "GetDatabaseSafety()从库id '" + path.Name + "' 找数据库对象失败";
return(-1);
}
// 如果有必要获得记录体
string strXml = "";
string strMetadata = "";
byte[] baTimestamp = null;
if (bXml == true || bTimestamp == true || bMetadata == true)
{
// 获得一条记录的 XML 字符串
// return:
// -1 出错
// -4 未找到记录
// -10 记录局部未找到
// 0 成功
long lRet = GetXmlBody(
db,
path.ID,
bXml,
bTimestamp,
bMetadata,
bWithResMetadata,
out strXml,
out strMetadata,
out baTimestamp,
out strError);
if (lRet <= -1)
{
record.RecordBody = new RecordBody();
record.RecordBody.Xml = strXml;
record.RecordBody.Metadata = strMetadata;
record.RecordBody.Timestamp = baTimestamp;
Result result = new Result();
result.Value = -1;
result.ErrorCode = KernelApplication.Ret2ErrorCode((int)lRet);
result.ErrorString = strError;
record.RecordBody.Result = result;
goto CONTINUE;
// return lRet;
}
#if NO
lTotalPackageLength += strXml.Length;
if (string.IsNullOrEmpty(strMetadata) == false)
{
lTotalPackageLength += strMetadata.Length;
}
if (baTimestamp != null)
{
lTotalPackageLength += baTimestamp.Length * 2;
}
if (lTotalPackageLength > QUOTA_SIZE &&
i > 0)
{
// 响应包的尺寸已经超过 1M，并且已经至少包含了一条记录
break;
}
#endif
record.RecordBody = new RecordBody();
record.RecordBody.Xml = strXml;
record.RecordBody.Metadata = strMetadata;
record.RecordBody.Timestamp = baTimestamp;
}
if (bKeyID == true)
{
// string strID = "";
string strKey = "";
// strID = dpRecord.ID;
strKey = dpRecord.BrowseText;
/*
* string strText = dpRecord.ID;
* nRet = strText.LastIndexOf(",");
* if (nRet != -1)
* {
* strKey = strText.Substring(0, nRet);
* strID = strText.Substring(nRet + 1);
* }
* else
* strID = strText;
* */
if (bHasID == true)
{
// GetCaptionSafety()函数先找到指定语言的库名;
// 如果没有找到,就找截短形态的语言的库名;
// 再找不到,就用第一种语言的库名。
// 如果连一种语言也没有，则返回库id
record.Path = db.GetCaptionSafety(strLang) + "/" + path.CompressedID;
// lTotalPackageLength += record.Path.Length;
}
if (bHasKey == true)
{
record.Keys = BuildKeyFromArray(strKey);
// lTotalPackageLength += GetLength(record.Keys);
}
if (bHasCols == true)
{
string[] cols;
nRet = db.GetCols(
strFormat,
path.ID10,
strXml,
0,
out cols);
// 2013/1/14
if (nRet == -1)
{
if (cols != null && cols.Length > 0)
{
strError = cols[0];
}
else
{
strError = "GetCols() error";
}
return(-1);
}
record.Cols = cols;
// lTotalPackageLength += nRet;
}
goto CONTINUE;
}
{
if (bHasID == true)
{
// GetCaptionSafety()函数先找到指定语言的库名;
// 如果没有找到,就找截短形态的语言的库名;
// 再找不到,就用第一种语言的库名。
// 如果连一种语言也没有，则返回库id
record.Path = db.GetCaptionSafety(strLang) + "/" + path.CompressedID;
// lTotalPackageLength += record.Path.Length;
}
// 在不是keyid的风格下(例如keycount，空)，cols全部是浏览列
if (bHasCols == true)
{
string[] cols;
nRet = db.GetCols(
strFormat,
path.ID10,
strXml,
0,
out cols);
// 2013/1/14
if (nRet == -1)
{
if (cols != null && cols.Length > 0)
{
strError = cols[0];
}
else
{
strError = "GetCols() error";
}
return(-1);
}
record.Cols = cols;
// lTotalPackageLength += nRet;
}
}
CONTINUE:
lTotalPackageLength += GetLength(record);
if (lTotalPackageLength > QUOTA_SIZE &&
i > 0)
{
// 响应包的尺寸已经超过 1M，并且已经至少包含了一条记录
break;
}
// records[i] = record;
results.Add(record);
Thread.Sleep(0); // 降低CPU耗用?
}
records = new Record[results.Count];
results.CopyTo(records);
return(resultSet.Count);
}
void FlushTable(Hashtable temp_table, DpResultSet resultset)
{
foreach (string path in temp_table.Keys)
{
this._app_down.Token.ThrowIfCancellationRequested();
DpRecord record_bibliorecpath = new DpRecord(path);
resultset.Add(record_bibliorecpath);
}
}
// 递归函数，得一个节点的集合，外面doSearch调该函数
// parameter:
// nodeRoot 当前根节点
// resultSet 结果集。返回时不能确保结果集已经排序。需要看resultset.Sorted成员
// return:
// -1 出错
// -6 无权限
// 0 成功
public int DoQuery(
SessionInfo sessioninfo,
string strOutputStyle,
XmlElement nodeRoot,
ref DpResultSet resultSet,
ChannelHandle handle,
// Delegate_isConnected isConnected,
out string strError)
{
DateTime start_time = DateTime.Now;
Debug.WriteLine("Begin DoQuery()");
try
{
strError = "";
if (nodeRoot == null)
{
strError = "DoQuery() nodeRoot参数不能为null。";
return -1;
}
#if NO
if (resultSet == null)
{
strError = "DoQuery() resultSet参数不能为null。";
return -1;
}
#endif
if (resultSet != null)
{
// 先清空一下
resultSet.Clear();
}
// 到item时不再继续递归
if (nodeRoot.Name == "item")
{
if (resultSet == null)
resultSet = sessioninfo.NewResultSet(); // 延迟创建
// return:
// -1 出错
// -6 无足够的权限
// 0 成功
return doItem(
sessioninfo,
strOutputStyle,
nodeRoot,
ref resultSet,
handle,
// isConnected,
out strError);
}
//如果为扩展节点，则不递归
if (nodeRoot.Name == "operator"
|| nodeRoot.Name == "lang")
{
return 0;
}
//将正常顺序变成逆波兰表序
ArrayList rpn;
// return:
// -1 出错 例如:括号不匹配;找不到某操作符的优先级
// 0 可用节点数为 0。等于没有任何可检索的必要
// 1 成功
int nRet = Infix2RPN(nodeRoot,
out rpn,
out strError);
if (nRet == -1)
{
strError = "逆波兰表错误:" + strError;
return -1;
}
if (nRet == 0)
return -1;
//属于正常情况
if (rpn.Count == 0)
return 0;
// return:
// -1 出错
// -6 无足够的权限
// 0 成功
nRet = ProceedRPN(
sessioninfo,
strOutputStyle,
rpn,
ref resultSet,
handle,
// isConnected,
out strError);
if (nRet <= -1)
return nRet;
return 0;
}
finally
{
TimeSpan delta = DateTime.Now - start_time;
Debug.WriteLine("End DoQuery() 耗时 " + delta.ToString());
}
}
const int MAX_COUNT_PER_GET = 100; // 每次最多可以获取的行数
// 获得任务当前信息
// 多线程：安全
// parameters:
// bDisplayAllIP 是否显示全部IP地址。如果为false，表示只显示访客的IP地址，并且是掩盖部分的
// return:
// -1 error
// 0 file not found
// 1 succeed
public int GetInfo(
string strDate,
long nStart,
long nCount,
bool bDisplayAllIP,
out ChatInfo info,
out string strError)
{
strError = "";
info = null;
if (strDate != this.Date)
{
// 要获得不是当天的内容
string strFileName = PathUtil.MergePath(DataDirectory, strDate);
if (File.Exists(strFileName) == false)
{
strError = "日期为 '" + strDate + "' 的文件不存在";
return(0);
}
DpResultSet resultset = new DpResultSet(false, false);
resultset.Attach(strFileName,
strFileName + ".index");
try
{
info = GetInfo(
resultset,
nStart,
nCount,
bDisplayAllIP);
}
finally
{
string strTemp1 = "";
string strTemp2 = "";
resultset.Detach(out strTemp1,
out strTemp2);
}
FileInfo fi = new FileInfo(strFileName);
info.ResultVersion = fi.LastWriteTimeUtc.Ticks;
return(1);
}
else
{
m_lock.EnterReadLock();
try
{
// 打开当天的内容文件
int nRet = PrepareContentFileName(out strError);
if (nRet == -1)
{
return(-1);
}
#if NO
ChatInfo info = new ChatInfo();
info.Name = this.Name;
long nMax = 0;
if (nCount == -1)
{
nMax = m_resultset.Count;
}
else
{
nMax = Math.Min(m_resultset.Count, nStart + nCount);
}
if (nMax - nStart > MAX_COUNT_PER_GET)
{
nMax = nStart + MAX_COUNT_PER_GET;
}
string strResult = "";
for (long i = nStart; i < nMax; i++)
{
DpRecord record = m_resultset[i];
if (bDisplayAllIP == true)
{
strResult += record.BrowseText;
}
else
{
strResult += RemoveIP(record.BrowseText);
}
}
info.ResultText = strResult;
info.NextStart = nMax; // 结束位置
info.TotalLines = m_resultset.Count;
info.ResultVersion = this.ContentFileVersion;
return(info);
#endif
info = GetInfo(
this.m_resultset,
nStart,
nCount,
bDisplayAllIP);
return(1);
}
finally
{
m_lock.ExitReadLock();
}
}
}
// 清除最近没有使用过的 ResultSet 对象
// parameters:
// delta 最近一次用过的时刻距离现在的时间长度。长于这个的对象才会被清除
public void Clean(TimeSpan delta)
{
List <string> remove_keys = new List <string>();
// 读锁定并不阻碍一般性访问
if (this.m_lock.TryEnterReadLock(m_nLockTimeout) == false)
{
throw new ApplicationException("锁定尝试中超时");
}
try
{
foreach (string key in this.Keys)
{
DpResultSet resultset = (DpResultSet)this[key];
if (resultset == null)
{
continue;
}
if (resultset.Permanent == true)
{
continue;
}
if ((DateTime.Now - resultset.LastUsedTime) >= delta)
{
remove_keys.Add(key); // 这里暂时无法删除，因为 foreach 还要用枚举器
}
}
}
finally
{
this.m_lock.ExitReadLock();
}
if (remove_keys.Count == 0)
{
return;
}
// 因为要删除某些元素，所以用写锁定
List <DpResultSet> delete_resultsets = new List <DpResultSet>();
if (this.m_lock.TryEnterWriteLock(m_nLockTimeout) == false)
{
throw new ApplicationException("锁定尝试中超时");
}
try
{
foreach (string key in remove_keys)
{
DpResultSet resultset = (DpResultSet)this[key];
if (resultset == null)
{
continue;
}
// 和 hashtable 脱离关系
this.Remove(key);
delete_resultsets.Add(resultset);
}
}
finally
{
this.m_lock.ExitWriteLock();
}
foreach (DpResultSet resultset in delete_resultsets)
{
// 2016/1/23
if (resultset != null)
{
resultset.GetTempFilename -= new GetTempFilenameEventHandler(resultset_GetTempFilename);
}
resultset.Close();
}
}
// 根据结果集文件初始化指纹高速缓存
// parameters:
// resultset 用于初始化的结果集对象。如果为 null，表示希望清空指纹高速缓存
// 一般可用 null 调用一次，然后用多个 resultset 对象逐个调用一次
// return:
// -1 出错
// >=0 实际发送给接口程序的事项数目
int CreateFingerprintCache(DpResultSet resultset,
out string strError)
{
strError = "";
int nRet = 0;
this.ShowMessage("加入高速缓存");
try
{
if (resultset == null)
{
// 清空以前的全部缓存内容，以便重新建立
// return:
// 0 成功
// 其他 失败。错误码
nRet = this.AddItems(
null,
out strError);
if (nRet != 0)
{
return(-1);
}
return(0);
}
int nSendCount = 0;
long nCount = resultset.Count;
List <FingerprintItem> items = new List <FingerprintItem>();
for (long i = 0; i < nCount; i++)
{
DpRecord record = resultset[i];
//string strTimestamp = "";
//string strBarcode = "";
//string strFingerprint = "";
ParseResultItemString(record.BrowseText,
out string strTimestamp,
out string strBarcode,
out string strFingerprint);
// TODO: 注意读者证条码号为空的，不要发送出去
FingerprintItem item = new FingerprintItem
{
ReaderBarcode = strBarcode,
FingerprintString = strFingerprint
};
items.Add(item);
if (items.Count >= 100)
{
// return:
// 0 成功
// 其他 失败。错误码
nRet = this.AddItems(
items,
out strError);
if (nRet != 0)
{
return(-1);
}
nSendCount += items.Count;
items.Clear();
}
}
if (items.Count > 0)
{
// return:
// 0 成功
// 其他 失败。错误码
nRet = this.AddItems(
items,
out strError);
if (nRet != 0)
{
return(-1);
}
nSendCount += items.Count;
}
// Console.Beep(); // 表示读取成功
return(nSendCount);
}
finally
{
}
}
// 检索
internal override int SearchByUnion(
string strOutputStyle,
SearchItem searchItem,
ChannelHandle handle,
// Delegate_isConnected isConnected,
DpResultSet resultSet,
int nWarningLevel,
out string strError,
out string strWarning)
{
strError = "";
strWarning = "";
//************对数据库加读锁**************
m_db_lock.AcquireReaderLock(m_nTimeOut);
#if DEBUG_LOCK
this.container.WriteDebugInfo("SearchByUnion()，对'" + this.GetCaption("zh-CN") + "'数据库加读锁。");
#endif
try
{
int nRet;
bool bHasID;
List<TableInfo> aTableInfo = null;
nRet = this.TableNames2aTableInfo(searchItem.TargetTables,
out bHasID,
out aTableInfo,
out strError);
if (nRet == -1)
return -1;
if (bHasID == true)
{
nRet = SearchByID(searchItem,
handle,
// isConnected,
resultSet,
out strError);
if (nRet == -1)
return -1;
}
if (aTableInfo == null || aTableInfo.Count == 0)
{
return 0;
}
for (int i = 0; i < aTableInfo.Count; i++)
{
TableInfo tableInfo = aTableInfo[i]; ;
string strTiaoJian = "";
try
{
nRet = GetKeyCondition(
searchItem,
tableInfo.nodeConvertQueryString,
tableInfo.nodeConvertQueryNumber,
out strTiaoJian,
out strError);
if (nRet == -1)
return -1;
}
catch (NoMatchException ex)
{
strWarning += ex.Message;
if (nWarningLevel == 0)
return -1;
}
XmlDocument dom = new XmlDocument();
dom.PreserveWhitespace = true; //设PreserveWhitespace为true
string strTablePath = this.TableName2TableFileName(tableInfo.SqlTableName);
try
{
dom.Load(strTablePath);
}
catch (Exception ex)
{
strError = "加载检索点表'" + tableInfo.SqlTableName + "'到dom出错：" + ex.Message;
return -1;
}
string strXpath = "/root/key[" + strTiaoJian + "]/idstring";
XmlNodeList listIdstring;
try
{
listIdstring = dom.SelectNodes(strXpath);
}
catch (System.Xml.XPath.XPathException ex)
{
strError += "Xpath出错:" + strXpath + "-------" + ex.Message + "<br/>";
return -1;
}
for (int j = 0; j < listIdstring.Count; j++)
{
string strIdstring = listIdstring[j].InnerText.Trim(); // 2012/2/16
string strId = this.FullID + "/" + strIdstring;
resultSet.Add(new DpRecord(strId));
}
}
//排序
resultSet.Sort();
//去重
resultSet.RemoveDup();
return 0;
}
finally
{
//*********对数据库解读锁************
m_db_lock.ReleaseReaderLock();
#if DEBUG_LOCK
this.container.WriteDebugInfo("SearchByUnion()，对'" + this.GetCaption("zh-CN") + "'数据库解读锁。");
#endif
}
}
// 检索单元item的信息，对库进行检索
// parameter:
// nodeItem item节点
// resultSet 传进结果集,????????每次清空，既然每次清空，那还不如返回一个结果集呢
// isConnected 是否连接
// strError out参数，返回出错信息
// return:
// -1 出错
// -6 无足够的权限
// 0 成功
public int doItem(XmlNode nodeItem,
DpResultSet resultSet,
Delegate_isConnected isConnected,
out string strError)
{
strError = "";
if (nodeItem == null)
{
strError = "doItem() nodeItem参数为null.";
return(-1);
}
if (resultSet == null)
{
strError = "doItem() oResult参数为null.";
return(-1);
}
//先清空一下
resultSet.Clear();
int nRet;
//调processRelation对检索单元的成员检查是否存在矛盾
//如果返回0，则可能对item的成员进行了修改，所以后面重新提取内容
nRet = ProcessRelation(nodeItem);
if (nRet == -1)
{
strError = "doItem()里调processRelation出错";
return(-1);
}
// 根据nodeItem得到检索信息
string strTarget;
string strWord;
string strMatch;
string strRelation;
string strDataType;
string strIdOrder;
string strKeyOrder;
string strOrderBy;
int nMaxCount;
nRet = QueryUtil.GetSearchInfo(nodeItem,
out strTarget,
out strWord,
out strMatch,
out strRelation,
out strDataType,
out strIdOrder,
out strKeyOrder,
out strOrderBy,
out nMaxCount,
out strError);
if (nRet == -1)
{
return(-1);
}
//将target以;号分成多个库
string[] aDatabase = strTarget.Split(new Char[] { ';' });
foreach (string strOneDatabase in aDatabase)
{
if (strOneDatabase == "")
{
continue;
}
string strDbName;
string strTableList;
// 拆分库名与途径
nRet = DatabaseUtil.SplitToDbNameAndForm(strOneDatabase,
out strDbName,
out strTableList,
out strError);
if (nRet == -1)
{
return(-1);
}
// 得到库
Database db = m_dbColl.GetDatabase(strDbName);
if (db == null)
{
strError = "未找到'" + strDbName + "'库";
return(-1);
}
string strTempRecordPath = db.GetCaption("zh-cn") + "/" + "record";
string strExistRights = "";
bool bHasRight = this.m_oUser.HasRights(strTempRecordPath,
ResType.Record,
"read",
out strExistRights);
if (bHasRight == false)
{
strError = "您的帐户名为'" + m_oUser.Name + "'" +
",对'" + strDbName + "'" +
"数据库中的记录没有'读(read)'权限，目前的权限为'" + strExistRights + "'。";
return(-6);
}
SearchItem searchItem = new SearchItem();
searchItem.TargetTables = strTableList;
searchItem.Word = strWord;
searchItem.Match = strMatch;
searchItem.Relation = strRelation;
searchItem.DataType = strDataType;
searchItem.IdOrder = strIdOrder;
searchItem.KeyOrder = strKeyOrder;
searchItem.OrderBy = strOrderBy;
searchItem.MaxCount = nMaxCount;
// 注: SearchByUnion不清空resultSet，从而使多个库的检索结结果放在一起
string strWarningInfo = "";
nRet = db.SearchByUnion(searchItem,
isConnected,
resultSet,
this.m_nWarningLevel,
out strError,
out strWarningInfo);
if (nRet == -1)
{
return(-1);
}
// 多个库的排序去重功能暂不做
//resultSet.Sort(); //按具体的风格排序
//resultSet.RemoveDup();
}
return(0);
}
