/// <summary>
/// 拓扑排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="edges">边集合</param>
/// <param name="points">无边点集合</param>
/// <param name="isDesc">是否反向排序</param>
/// <returns>排序结果</returns>
public static valueType[] Sort <valueType>(ICollection <KeyValue <valueType, valueType> > edges, HashSet <valueType> points, bool isDesc = false)
where valueType : IEquatable <valueType>
{
if (edges.count() == 0)
{
return(points.getArray());
}
Dictionary <valueType, ListArray <valueType> > graph = DictionaryCreator.CreateAny <valueType, ListArray <valueType> >();
if (points == null)
{
points = HashSetCreator.CreateAny <valueType>();
}
ListArray <valueType> values;
foreach (KeyValue <valueType, valueType> edge in edges)
{
if (!graph.TryGetValue(edge.Key, out values))
{
graph.Add(edge.Key, values = new ListArray <valueType>());
}
values.Add(edge.Value);
points.Add(edge.Value);
}
LeftArray <valueType> pointList = new LeftArray <valueType>(points.Count);
foreach (valueType point in points)
{
if (!graph.ContainsKey(point))
{
pointList.UnsafeAdd(point);
}
}
return(new Sorter <valueType>(graph, ref pointList, isDesc).Sort());
}
/// <summary>
/// 复制数据
/// </summary>
/// <param name="array"></param>
public void CopyTo(ref LeftArray <KeyValuePair <keyType, ResultIndexArray> > array)
{
array.PrepLength(Dictionary.Count);
foreach (KeyValuePair <keyType, ResultIndexArray> value in Dictionary)
{
array.UnsafeAdd(value);
}
}
/// <summary>
/// 加载数据结构索引标识
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
private bool loadIndexIdentity(ref OperationParameter.NodeParser parser)
{
if (parser.ReadInt() == Array.Length)
{
FreeIndexs.PrepLength(Array.Length);
ServerDataStructure dataStructure;
for (int index = Array.Length; index != 0;)
{
if (!Array[--index].Load((ulong)parser.ReadLong(), out dataStructure))
{
return(false);
}
if (dataStructure == null)
{
FreeIndexs.UnsafeAdd(index);
}
}
isRebuild = false;
return(true);
}
return(false);
}
/// <summary>
/// 获取表格名称集合
/// </summary>
/// <returns></returns>
public override LeftArray <string> GetTableNames()
{
using (DbConnection dbConnection = GetConnection())
using (DataTable table = ((OleDbConnection)dbConnection).GetOleDbSchemaTable(System.Data.OleDb.OleDbSchemaGuid.Tables, null))
{
DataRowCollection rows = table.Rows;
LeftArray <string> names = new LeftArray <string>(rows.Count);
foreach (DataRow row in rows)
{
names.UnsafeAdd(row[schemaTableName].ToString());
}
return(names);
}
}
/// <summary>
/// 添加数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="array">数据数组</param>
/// <returns></returns>
internal override SubArray <valueType> Insert <valueType, modelType>(Table <valueType, modelType> sqlTool, ref DbConnection connection, ref SubArray <valueType> array)
{
MemberMap <modelType> memberMap = MemberMap <modelType> .Default;
InsertQuery query = new InsertQuery();
LeftArray <valueType> newArray = new LeftArray <valueType>(array.Length);
foreach (valueType value in array)
{
insert(sqlTool, value, memberMap, ref query);
if (Insert(sqlTool, ref connection, value, ref query))
{
newArray.UnsafeAdd(value);
}
}
return(new SubArray <valueType>(ref newArray));
}
/// <summary>
/// TCP 服务信息集合
/// </summary>
/// <param name="cache"></param>
/// <param name="registerServer"></param>
internal ServerSet(ServerSetCache cache, Server registerServer)
{
Server = new Log {
Type = LogType.RegisterServer, Server = cache.Server
};
registerServer.SetIpPort(cache.Server);
if (cache.Servers != null)
{
Servers.PrepLength(cache.Servers.Length);
foreach (ServerInfo server in cache.Servers)
{
Servers.UnsafeAdd(new Log {
Type = LogType.RegisterServer, Server = server
});
registerServer.SetIpPort(server);
}
}
}
/// <summary>
/// 根据表格名称获取表格信息
/// </summary>
/// <param name="connection">SQL连接</param>
/// <param name="tableName">表格名称</param>
/// <returns>表格信息</returns>
internal override TableColumnCollection GetTable(DbConnection connection, string tableName)
{
using (DbCommand command = getCommand(connection, "select top 1 * from [" + tableName + "]", CommandType.Text))
using (DataSet dataSet = getDataSet(command))
{
DataTable table = dataSet.Tables[0];
Column identity = null;
LeftArray <Column> columns = new LeftArray <Column>(table.Columns.Count);
foreach (DataColumn dataColumn in table.Columns)
{
Column column = new Column
{
Name = dataColumn.ColumnName,
DbType = Sql.DbType.formCSharpType(dataColumn.DataType),
Size = dataColumn.MaxLength,
DefaultValue = dataColumn.DefaultValue == null ? null : dataColumn.DefaultValue.ToString(),
IsNull = dataColumn.AllowDBNull,
};
if (dataColumn.AutoIncrement)
{
identity = column;
}
columns.UnsafeAdd(column);
}
return(new TableColumnCollection
{
Columns = new ColumnCollection
{
Name = tableName,
Columns = columns.Array,
Type = ColumnCollectionType.None
},
Identity = identity
});
}
}
unsafe static Sign()
{
Type type = typeof(valueType);
if (type.IsArray || type.IsEnum || type.IsPointer || type.IsInterface)
{
return;
}
SignAttribute attribute = AutoCSer.Metadata.TypeAttribute.GetAttribute <SignAttribute>(type, true) ?? SignAttribute.AllMember;
LeftArray <FieldIndex> fields = AutoCSer.Net.WebClient.Emit.Pub.GetFields <valueType, SignMemberAttribute>(attribute.Filter, attribute.IsAllMember);
LeftArray <PropertyIndex> properties = Emit.Pub.GetProperties <valueType, SignMemberAttribute>(attribute.Filter, attribute.IsAllMember, true, false);
int count = fields.Length + properties.Length - 1;
if (count < 0)
{
return;
}
LeftArray <KeyValue <FieldIndex, PropertyIndex> > members = new LeftArray <KeyValue <FieldIndex, PropertyIndex> >(count);
FieldInfo signField = null;
PropertyInfo signProperty = null;
foreach (FieldIndex field in fields)
{
if (field.Member.Name == "sign")
{
if (field.Member.FieldType != typeof(string))
{
return;
}
signField = field.Member;
}
else
{
members.UnsafeAdd(new KeyValue <FieldIndex, PropertyIndex>(field, null));
}
}
foreach (PropertyIndex property in properties)
{
if (property.Member.Name == "sign")
{
if (property.Member.PropertyType != typeof(string))
{
return;
}
signProperty = property.Member;
}
else
{
members.UnsafeAdd(new KeyValue <FieldIndex, PropertyIndex>(null, property));
}
}
if ((signField == null) ^ (signProperty == null))
{
setSign = signField == null?Emit.Property.SetProperty <valueType, string>(signProperty) : AutoCSer.Emit.Field.UnsafeSetField <valueType, string>(signField);
if (count == 0)
{
names = EmptyArray <string> .Array;
valueGetter = empty;
}
else
{
members.Array.sort(SignAttribute.NameCompare);
names = new string[memberCount = count];
isUtf8 = Unmanaged.GetStaticPointer(((count + 31) >> 5) << 2, true);
#if NOJIT
signer signer = new signer(members.Array.Length);
#else
SignDynamicMethod dynamicMethod = new SignDynamicMethod(type);
#endif
MemoryMap utf8Map = new MemoryMap(isUtf8.Byte);
count = 0;
foreach (KeyValue <FieldIndex, PropertyIndex> member in members.Array)
{
#if NOJIT
if (member.Key == null ? signer.Push(member.Value, count) : signer.Push(member.Key, count))
{
utf8Map.Set(count);
}
#else
if (member.Key == null ? dynamicMethod.Push(member.Value, count) : dynamicMethod.Push(member.Key, count))
{
utf8Map.Set(count);
}
#endif
names[count++] = member.Key == null ? member.Value.Member.Name : member.Key.Member.Name;
}
#if NOJIT
valueGetter = signer.Sign;
#else
valueGetter = (Action <valueType, string[]>)dynamicMethod.Create <Action <valueType, string[]> >();
#endif
}
}
}
/// <summary>
/// 服务端映射标识检测
/// </summary>
/// <param name="node"></param>
/// <param name="types"></param>
/// <returns>是否映射成功</returns>
internal unsafe AutoCSer.Net.TcpServer.ReturnType Check(Node node, ref LeftArray <Type> types)
{
node.CheckServerNodeId(this, ref types);
if (types.Length == 0)
{
return(AutoCSer.Net.TcpServer.ReturnType.Success);
}
int count = types.Length;
LeftArray <AutoCSer.Reflection.RemoteType> remoteTypes = new LeftArray <AutoCSer.Reflection.RemoteType>(types.Length);
types.Length = 0;
AutoCSer.Net.TcpServer.ReturnType returnType = AutoCSer.Net.TcpServer.ReturnType.Success;
Monitor.Enter(serverNodeIdLock);
try
{
foreach (Type type in types.Array)
{
if (!ServerNodeIds.ContainsKey(type))
{
types.UnsafeAdd(type);
remoteTypes.Add(type);
}
if (--count == 0)
{
break;
}
}
if ((count = types.Length) != 0)
{
AutoCSer.Net.TcpServer.ReturnValue <int[]> ids = Get(remoteTypes.ToArray());
if (ids.Type == TcpServer.ReturnType.Success)
{
fixed(int *idFixed = ids.Value)
{
int *idStart = idFixed;
foreach (Type type in types.Array)
{
if (*idStart == 0)
{
returnType = TcpServer.ReturnType.RemoteExpressionServerNodeError;
}
else
{
ServerNodeIds[type] = *idStart;
}
if (--count == 0)
{
break;
}
++idStart;
}
}
}
else
{
returnType = ids.Type;
}
}
}
finally { Monitor.Exit(serverNodeIdLock); }
return(returnType);
}
/// <summary>
/// 获取搜索数据标识集合（匹配所有分词结果）
/// </summary>
/// <param name="text">搜索关键字</param>
/// <param name="maxSize">关键字最大字符长度</param>
/// <param name="isKey">数据标识过滤</param>
/// <returns>数据标识集合</returns>
public LeftArray <keyType> SearchAll(string text, int maxSize, Func <keyType, bool> isKey = null)
{
resultArray.Length = 0;
Simplified.Set(text, maxSize);
Search(true);
switch (queryResult.Count)
{
case 0: break;
case 1:
foreach (KeyValuePair <keyType, ResultIndexArray> result in queryResult[0].Value.Dictionary)
{
if (isKey(result.Key))
{
resultArray.Add(result.Key);
}
}
break;
default:
Dictionary <keyType, ResultIndexArray> resultDictionary = null;
foreach (KeyValue <HashString, QueryResult> result in queryResult)
{
if (resultDictionary == null || result.Value.Dictionary.Count < resultDictionary.Count)
{
resultDictionary = result.Value.Dictionary;
}
}
resultCountDictionary.Empty();
foreach (keyType key in resultDictionary.Keys)
{
if (isKey(key))
{
resultCountDictionary.Set(key, 0);
}
}
if (resultCountDictionary.Count != 0)
{
int count = 0, keyCount = resultCountDictionary.Count;
foreach (KeyValue <HashString, QueryResult> result in queryResult)
{
if (!object.ReferenceEquals(result.Value.Dictionary, resultDictionary))
{
int nextCount = count + 1, resultCount;
keyCount = 0;
foreach (keyType key in result.Value.Dictionary.Keys)
{
if (resultCountDictionary.TryGetValue(key, out resultCount) && resultCount == count)
{
resultCountDictionary.Set(key, nextCount);
++keyCount;
}
}
if (keyCount == 0)
{
resultCountDictionary.Empty();
break;
}
count = nextCount;
}
}
if (keyCount > 0)
{
resultArray.PrepLength(keyCount);
foreach (KeyValue <keyType, int> result in resultCountDictionary.KeyValues)
{
if (result.Value == count)
{
resultArray.UnsafeAdd(result.Key);
}
}
}
}
break;
}
return(resultArray);
}
