/// <summary>
/// 优化主要包括的是支持顺序查询
/// </summary>
/// <param name="dataSourceName"></param>
/// <param name="sqlUnits"></param>
/// <param name="callback"></param>
/// <returns></returns>
private List <InputGroup <CommandExecuteUnit> > GetSqlExecuteGroups(string dataSourceName, List <SqlUnit> sqlUnits,
ISqlExecutePrepareCallback callback)
{
ICollection <InputGroup <CommandExecuteUnit> > result = new LinkedList <InputGroup <CommandExecuteUnit> >();
int desiredPartitionSize =
Math.Max(
0 == sqlUnits.Count % _maxConnectionsSizePerQuery
? sqlUnits.Count / _maxConnectionsSizePerQuery
: sqlUnits.Count / _maxConnectionsSizePerQuery + 1, 1);
List <List <SqlUnit> > sqlUnitPartitions = sqlUnits
.Select((o, i) => new { Obj = o, index = i % desiredPartitionSize }).GroupBy(o => o.index)
.Select(o => o.Select(g => g.Obj).ToList()).ToList();
ConnectionModeEnum connectionMode = _maxConnectionsSizePerQuery < sqlUnits.Count
? ConnectionModeEnum.CONNECTION_STRICTLY
: ConnectionModeEnum.MEMORY_STRICTLY;
List <DbConnection> connections =
callback.GetConnections(connectionMode, dataSourceName, sqlUnitPartitions.Count);
int count = 0;
foreach (var item in sqlUnitPartitions)
{
result.Add(GetSqlExecuteGroup(connectionMode, connections[count++], dataSourceName, item, callback));
}
return(result.ToList());
}
public List <DbConnection> GetConnections(ConnectionModeEnum connectionMode, string dataSourceName, int connectionSize)
{
var dbConnections = _commandExecutor.Connection.GetConnections(connectionMode, dataSourceName, connectionSize);
//dbConnections.ForEach(o=>o.Open());
return(dbConnections);
}
private List <DbConnection> CreateConnections(string dataSourceName, ConnectionModeEnum connectionMode, IDataSource dataSource, int connectionSize)
{
if (1 == connectionSize)
{
if (dataSource.IsDefault())
{
return(new List <DbConnection>()
{
GetDefaultDbConnection()
});
}
var connection = CreateConnection(dataSourceName, dataSource);
ReplyTargetMethodInvoke(connection);
return(new List <DbConnection>()
{
connection
});
}
if (ConnectionModeEnum.CONNECTION_STRICTLY == connectionMode)
{
return(CreateConnections(dataSourceName, dataSource, connectionSize));
}
lock (dataSource)
{
return(CreateConnections(dataSourceName, dataSource, connectionSize));
}
}
private int DoExecuteNonQuery(string sql, DbCommand command, ConnectionModeEnum connectionMode)
{
// DbDataReader resultSet = command.ExecuteReader(sql);
// command.CommandText = sql;
var i = command.ExecuteNonQuery();
return(i);
}
private IStreamDataReader GetQueryEnumerator(string sql, DbCommand command, ConnectionModeEnum connectionMode)
{
// DbDataReader resultSet = command.ExecuteReader(sql);
// command.CommandText = sql;
DbDataReader resultSet = command.ExecuteReader();
DbDataReaders.Add(resultSet);
if (ConnectionModeEnum.MEMORY_STRICTLY == connectionMode)
{
return(new StreamQueryDataReader(resultSet));
}
return(new MemoryQueryDataReader(resultSet));
}
private InputGroup <CommandExecuteUnit> GetSqlExecuteGroup(ConnectionModeEnum connectionMode,
DbConnection connection,
string dataSourceName, List <SqlUnit> sqlUnitGroup, ISqlExecutePrepareCallback callback)
{
List <CommandExecuteUnit> result = new List <CommandExecuteUnit>();
foreach (var sqlUnit in sqlUnitGroup)
{
result.Add(callback.CreateCommandExecuteUnit(connection, new ExecutionUnit(dataSourceName, sqlUnit),
connectionMode));
}
return(new InputGroup <CommandExecuteUnit>(result));
}
public CommandExecuteUnit CreateCommandExecuteUnit(DbConnection connection, ExecutionUnit executionUnit,
ConnectionModeEnum connectionMode)
{
var shardingParameters = executionUnit.GetSqlUnit().GetParameterContext().GetDbParameters().Select(o => (ShardingParameter)o).ToList();
var dbCommand = connection.CreateCommand();
//TODO取消手动执行改成replay
dbCommand.CommandText = executionUnit.GetSqlUnit().GetSql();
foreach (var shardingParameter in shardingParameters)
{
var dbParameter = dbCommand.CreateParameter();
dbParameter.ParameterName = shardingParameter.ParameterName;
dbParameter.Value = shardingParameter.Value;
dbCommand.Parameters.Add(dbParameter);
}
return(new CommandExecuteUnit(executionUnit, dbCommand, connectionMode));
}
public List <DbConnection> GetConnections(ConnectionModeEnum connectionMode, string dataSourceName, int connectionSize)
{
var dataSourceMap = GetDataSourceMap();
if (!dataSourceMap.ContainsKey(dataSourceName))
{
throw new ShardingException($"missing the data source name: '{dataSourceName}'");
}
IDataSource dataSource = dataSourceMap[dataSourceName];
//ICollection<DbConnection> connections;
//lock (cachedConnections)
//{
// connections = cachedConnections.GetValues(dataSourceName, true);
//}
//List<DbConnection> result;
//if (connections.Count >= connectionSize)
//{
// result = new List<DbConnection>(connections).GetRange(0, connectionSize);
//}
//else if (connections.Any())
//{
// result = new List<DbConnection>(connections);
// List<DbConnection> newConnections = CreateConnections(dataSourceName, connectionMode, dataSource, connectionSize - connections.Count);
// result.AddRange(newConnections);
// lock (cachedConnections)
// {
// cachedConnections.AddRange(dataSourceName, newConnections);
// }
//}
//else
//{
// result = new List<DbConnection>(CreateConnections(dataSourceName, connectionMode, dataSource, connectionSize));
// lock (cachedConnections)
// {
// cachedConnections.AddRange(dataSourceName, result);
// }
//}
_connections = new List <DbConnection>(CreateConnections(dataSourceName, connectionMode, dataSource, connectionSize));
return(_connections);
}
public CommandExecuteUnit(ExecutionUnit executionUnit, DbCommand command, ConnectionModeEnum connectionMode)
{
ExecutionUnit = executionUnit;
Command = command;
ConnectionMode = connectionMode;
}
public DataSourceSqlExecutorUnit(ConnectionModeEnum connectionMode, List <SqlExecutorGroup <CommandExecuteUnit> > sqlExecutorGroups)
{
ConnectionMode = connectionMode;
SqlExecutorGroups = sqlExecutorGroups;
}
private static AbstractHttpStream OpenStream(
string scheme, string host, int port,
X509CertificateCollection clientCertificates,
SslProtocols enabledSslProtocols,
bool checkCertificateRevocation,
ConnectionModeEnum reuseMode,
RemoteCertificateValidationCallback remoteCertificateValidationCallback,
bool enableIPv6)
{
if (reuseMode == ConnectionModeEnum.UpgradeHttp2 && scheme != Uri.UriSchemeHttp)
{
throw new ArgumentException(nameof(reuseMode));
}
if (reuseMode != ConnectionModeEnum.SingleRequest)
{
string key = scheme + "://" + host + ":" + port.ToString();
RwLockedList <StreamInfo> streaminfo;
if (m_StreamList.TryGetValue(key, out streaminfo))
{
AbstractHttpStream stream = null;
lock (streaminfo)
{
if (streaminfo.Count > 0)
{
if ((streaminfo[0].ValidUntil - Environment.TickCount) > 0)
{
stream = streaminfo[0].Stream;
}
streaminfo.RemoveAt(0);
}
}
m_StreamList.RemoveIf(key, (RwLockedList <StreamInfo> info) => info.Count == 0);
if (stream != null)
{
if (reuseMode == ConnectionModeEnum.Close)
{
stream.IsReusable = false;
}
return(stream);
}
}
}
if (scheme == Uri.UriSchemeHttp)
{
return(new HttpStream(ConnectToTcp(host, port, enableIPv6))
{
IsReusable = reuseMode == ConnectionModeEnum.Keepalive
});
}
else if (scheme == Uri.UriSchemeHttps)
{
return(ConnectToSslServer(host, port, clientCertificates, enabledSslProtocols, checkCertificateRevocation, reuseMode == ConnectionModeEnum.Keepalive, remoteCertificateValidationCallback, enableIPv6));
}
else
{
throw new NotSupportedException();
}
}
public SqlExecutorGroup(ConnectionModeEnum connectionMode,List<T> groups)
{
ConnectionMode = connectionMode;
Groups = groups;
}
