internal static WhereChainer WhereQuantified(this IWhere prev, INonSelectView nonSelectView, bool sign, Predicate predicate)
{
var expression = predicate.Quantifier
.CreateExpression(((ISelect)nonSelectView).SelectCountBig().EndView());
return(Where(prev, expression, sign, predicate.PredicateGroup));
}
/// <summary>
/// 指定の子ノードを取り除く
/// </summary>
/// <param name="child">子ノード</param>
public void RemoveChild(IQueryNode child)
{
if (this.WhereNode == child)
{
this.WhereNode = null;
}
}
public WhereExpression(string field, object value, CompareType type, IWhere <T> where)
{
this.FieldName = field;
this.CompareType = type;
this.Value = value;
this.Next = where;
}
/// <summary>
/// REplaces the current where clause with the passed clause
/// </summary>
/// <param name="queryBuilder"></param>
/// <param name="where"></param>
/// <returns></returns>
public static IQueryBuilder WhereAll(this IQueryBuilder queryBuilder, IWhere where)
{
var qb = queryBuilder.Clone();
qb.QueryDef.Where.Clear();
qb.QueryDef.Where.Add(where);
return qb;
}
/// <summary>
/// Adds the where clause to the current conditions
/// </summary>
/// <param name="queryBuilder"></param>
/// <param name="where"></param>
/// <returns></returns>
public static IQueryBuilder Where(this IQueryBuilder queryBuilder, IWhere where)
{
var qb = queryBuilder.Clone();
qb.QueryDef.Where.Add(where);
return(qb);
}
public static IQuery Delete(this IWhere query)
{
if (query.Condition == "1")
{
return(new Query(query.Table, $"DELETE FROM `{query.Table.TableName}`;"));
}
return(new Query(query.Table, $"DELETE FROM `{query.Table.TableName}` WHERE {query.Condition};"));
}
private PersonCore GetSingle_PersonCore(IDbConnection conn, IWhere where)
{
var single = conn.SelectSingle<PersonCore>("PersonCore")
.Fields("PK_User,Code,Name,ShortName,IDCardNumber,Sex,Age,Email,Mobile,Birthdate,JoinWorkDate,Censusaddr,NC_PK_User,NC_Modifiedtime")
.Where(where)
.Execute();
return single;
}
private Department GetSingle_Department(IDbConnection conn, IWhere where)
{
var single = conn.SelectSingle<Department>("Department")
.Fields("PK_Dept,InnerCode,Name,PK_FDept,PK_Org,PK_Group,NC_PK_Dept,NC_Modifiedtime")
.Where(where)
.Execute();
return single;
}
private OrgGroup GetSingle_OrgGroup(IDbConnection conn, IWhere where)
{
var single = conn.SelectSingle<OrgGroup>("OrgGroup")
.Fields("PK_Group,InnerCode,Name,NC_PK_Group,NC_Modifiedtime")
.Where(where)
.Execute();
return single;
}
private Organization GetSingle_Organization(IDbConnection conn, IWhere where)
{
var single = conn.SelectSingle<Organization>("Organization")
.Fields("PK_Org,InnerCode,Name,ShortName,PK_FOrg,PK_Group,NC_PK_Org,NC_Modifiedtime")
.Where(where)
.Execute();
return single;
}
public Context(IWho who, IWhat what, IWhere where, IWhen when, IWhy why)
{
Who = who;
What = what;
Where = where;
When = when;
Why = why;
}
public static IQuery Select(this IWhere query, params string[] columns)
{
if (query.Condition == "1")
{
return(new Query(query.Table, $"SELECT {string.Join(", ", columns)} FROM `{query.Table.TableName}`;"));
}
return(new Query(query.Table, $"SELECT {string.Join(", ", columns)} FROM `{query.Table.TableName}` WHERE {query.Condition};"));
}
public static IQuery Select(this IWhere query)
{
if (query.Condition == "1")
{
return(new Query(query.Table, $"SELECT * FROM `{query.Table.TableName}`;"));
}
return(new Query(query.Table, $"SELECT * FROM `{query.Table.TableName}` WHERE {query.Condition};"));
}
public void Update(IUpdate <T> update, IWhere <T> where)
{
IUpdateCommand <T> command = new UpdateCommand()
{
Update = update, Where = where
};
ExecuteUpdate(command);
}
public From <TColumns> Where(IWhere where)
{
if (this.WhereNode != null)
{
throw new ApplicationException();
}
QueryNodeHelper.SwitchParent(where, this);
this.WhereNode = where;
return(this);
}
public ValueSetter Where(IWhere where)
{
if (this.WhereNode != null)
{
throw new ApplicationException();
}
QueryNodeHelper.SwitchParent(where, this);
this.WhereNode = where;
return(this);
}
public static IWhere Where(this IWhere where, Expression <Func <IRow, bool> > predicate)
{
var condition = new ToSqlExpression().Visit(new SimplifyExpression().Visit(predicate.Body));
if (condition is ConstantExpression c && c.Value is string s)
{
return(new Where(where.Table, $"({where.Condition}) AND ({s})"));
}
throw new Exception();
}
public GetBudgetById(
Neo4JConnection connection,
IEnumerable <IWhere <string, Filter> > where)
{
where = where.ToList();
this.connection = connection;
this.where = where.First(item => item.Name == typeof(Where).FullName);
this.whereTransaction = where.First(item => item.Name == typeof(WhereTransaction).FullName);
}
/// <summary>
/// @xis 待入库列表
/// </summary>
/// <param name="reqmodel"></param>
/// <returns></returns>
public async Task <Result> SearchStockPaginerAsync(reqmodel <SearchStockPreModel> reqmodel)
{
Result <PaginerData <SearchStockPrePaginerResult> > result = new Result <PaginerData <SearchStockPrePaginerResult> > {
status = ErrorCodeConst.ERROR_200, code = ErrorCodeConst.ERROR_200
};
IWhere <t_stock> stock_data_mkr = g_sqlMaker.Select <t_stock>(s => new { s.id, s.product_name }).Where();
IWhere <t_stockin_pre> stock_pre_data_mkr = g_sqlMaker.Select <t_stockin_pre>(s => new { s.id, s.stock_id, s.quantity }).Where();
IWhere <t_stockin_pre> stock_pre_total_mkr = g_sqlMaker.Select <t_stockin_pre>().Count().Where();
//模糊查询产品
List <t_stock> stock_list = new List <t_stock>();
if (!string.IsNullOrWhiteSpace(reqmodel.Data.name))
{
stock_data_mkr = stock_data_mkr.And("product_name", "like", "@product_name");
stock_pre_data_mkr = stock_pre_data_mkr.And("stock_id", "in", "@stock_id");
stock_pre_total_mkr = stock_pre_total_mkr.And("stock_id", "in", "@stock_id");
stock_list = await g_dbHelper.QueryListAsync <t_stock>(stock_data_mkr.ToSQL(), new { product_name = $"%{reqmodel.Data.name}%" });
}
//查询待入库
string stock_pre_data_sql = stock_pre_data_mkr.OrderByDesc("add_time").Pager(reqmodel.Data.page_index, reqmodel.Data.page_size).ToSQL();
List <t_stockin_pre> stock_pre_list = await g_dbHelper.QueryListAsync <t_stockin_pre>(stock_pre_data_sql, new { stock_id = stock_list.Select(s => s.id) });
int total = await g_dbHelper.QueryAsync <int>(stock_pre_total_mkr.ToSQL(), new { stock_id = stock_list.Select(s => s.id) });
if (string.IsNullOrWhiteSpace(reqmodel.Data.name) && stock_pre_list.Count > 0)
{
stock_list = await g_dbHelper.QueryListAsync <t_stock>(stock_data_mkr.And("id", "in", "@stock_id").ToSQL(), new { stock_id = stock_pre_list.Select(s => s.stock_id) });
}
List <SearchStockPrePaginerResult> search_list = new List <SearchStockPrePaginerResult>();
foreach (var item in stock_pre_list)
{
t_stock stock = stock_list.First(f => f.id == item.stock_id);
search_list.Add(new SearchStockPrePaginerResult
{
id = item.id,
stock_id = item.stock_id,
quantity = item.quantity,
product_name = stock.product_name,
});
}
PaginerData <SearchStockPrePaginerResult> paginer = new PaginerData <SearchStockPrePaginerResult>
{
page_index = reqmodel.Data.page_index,
page_size = reqmodel.Data.page_size,
Data = search_list,
total = total
};
result.data = paginer;
return(result);
}
public GetTransactions(
Neo4JConnection connection,
ILimit <int, Filter> limit,
ISkip <int, Filter> skip,
IEnumerable <IWhere <string, Filter> > where)
{
this.connection = connection;
this.limit = limit;
this.skip = skip;
this.where = where.First(item => item.Name == typeof(Where).FullName);
}
internal static WhereChainer Where(this IWhere prev, Expression condition, bool sign, PredicateGroup predicateGroup = null)
{
if (sign)
{
return(new WhereChainer((Chainer)prev, condition, predicateGroup));
}
else
{
return(new WhereChainer((Chainer)prev, condition.Not(), predicateGroup));
}
}
public SQL()
{
sql = new StringBuilder();
twhere = new TWhere(this.sql);
tfrom = new TFrom(this.sql);
tselect = new TSelect(this.sql, this.tfrom, twhere);
tinsert = new TInsert(this.sql, this.tselect);
tcondition = new TCondition(sql);
tdelete = new TDelete(sql);
tupdate = new TUpdate(sql);
}
public static WebConfigList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTERNET, TABLE, whereClause, orderByClause, true);
WebConfigList list = new WebConfigList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public static MustShowControlViewList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTRANET, TABLE, whereClause, orderByClause, true);
MustShowControlViewList list = new MustShowControlViewList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
/// <summary>
/// @lx 获取所有仓库信息
/// </summary>
/// <param name="selector">选择器</param>
/// <param name="normal"></param>
/// <returns></returns>
public async Task <List <t_ware> > GetAllWares(Func <t_ware, dynamic> selector, bool normal = true)
{
IWhere <t_ware> sql_select = g_sqlMaker.Select(selector).Where();
if (normal)
{
sql_select = sql_select.And("status", "=", "@status").And("state", "=", "@state");
}
List <t_ware> data_list = await g_dbHelper.QueryListAsync <t_ware>(sql_select.ToSQL(), new { status = (int)EnumStatus.Enable, state = (int)EnumState.Normal });
return(data_list);
}
public static EmployeeOtherControlsSubscriptionsViewList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTRANET, TABLE, whereClause, orderByClause, true);
EmployeeOtherControlsSubscriptionsViewList list = new EmployeeOtherControlsSubscriptionsViewList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public static KnowledgebasesSectionsArticlesSeeAlsoList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTRANET, TABLE, whereClause, orderByClause, true);
KnowledgebasesSectionsArticlesSeeAlsoList list = new KnowledgebasesSectionsArticlesSeeAlsoList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public override bool Equals(object obj)
{
IWhere other = obj as IWhere;
if (other == null || GetSql() != other.GetSql())
{
return(false);
}
SetComparer <IDataParameter> comparer = new SetComparer <IDataParameter>(Parameters, other.Parameters);
return(comparer.AreEqual);
}
public static OrgGroupsEmployeesList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTRANET, TABLE, whereClause, orderByClause, true);
OrgGroupsEmployeesList list = new OrgGroupsEmployeesList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public static EventList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.ORDERDB, TABLE, whereClause, orderByClause, true);
EventList list = new EventList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public static CalendarsItemsLocationsList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTRANET, TABLE, whereClause, orderByClause, true);
CalendarsItemsLocationsList list = new CalendarsItemsLocationsList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public static IWhere WhereIn <T>(this IWhere where, string columnName, IEnumerable <T> values, bool skipBrackets = false)
{
var str = string.Join(", ", values);
if (skipBrackets)
{
return(new Where(where.Table, $"{where.Condition} AND `{columnName}` IN ({str})"));
}
else
{
return(new Where(where.Table, $"({where.Condition}) AND (`{columnName}` IN ({str}))"));
}
}
public IWhereClause Add(IWhere criterion)
{
if (criterion == null)
{
throw new Exception("Can't add a null value to a WhereClause");
}
if (!CriteriaList.Contains(criterion)) {
criterion.Owner = Owner;
CriteriaList.Add(criterion);
}
return this;
}
public GetAll(
ISkip<Filter.Simple.Data.Filter> skip,
ILimit<Filter.Simple.Data.Filter> limit,
IWhere<Filter.Simple.Data.Filter, SimpleExpression> where,
IOrder<Filter.Simple.Data.Filter, ObjectReference> order,
IOrderDirection<Filter.Simple.Data.Filter, OrderByDirection> orderDirection)
{
_skip = skip;
_limit = limit;
_where = where;
_order = order;
_orderDirection = orderDirection;
}
/// <summary>
/// Returns an ordered and filtered list of Payment rows.
/// </summary>
/// <param name="whereClause">Filtering criteria.</param>
/// <param name="orderByClause">Ordering criteria.</param>
/// <returns>List of PaymentData objects.</returns>
/// <exception cref="Spring2.Core.DAO.FinderException">Thrown when no rows are found matching the where criteria.</exception>
public static IList GetList(IWhere whereClause, IOrderBy orderByClause, Int32 maxRows)
{
SqlDataReader dataReader = GetListReader(CONNECTION_STRING_KEY, VIEW, whereClause, orderByClause, maxRows);
ArrayList list = new ArrayList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public IWhereClause Add(IWhere criterion)
{
if (criterion == null)
{
throw new Exception("Can't add a null value to a WhereClause");
}
if (!CriteriaList.Contains(criterion))
{
criterion.Owner = Owner;
CriteriaList.Add(criterion);
}
return(this);
}
protected int Delete(IWhere query)
{
var from = From.TableOrView(GetTableName());
var delStatement = Statements.Delete.From(from).Where(query);
try
{
return(Execute().ExecuteNonQuery(delStatement.GetSqlCommand(TableDefinition)));
}
catch (Exception e)
{
Logger.Error(e, "Delete", delStatement.GetSqlCommand(TableDefinition).CommandAsPlainText());
throw;
}
}
internal List<Organization> GetOrganization(IDbConnection conn, IWhere where = null)
{
string tableName = "Organization";
string fields = "PK_Org,InnerCode,Name,ShortName,PK_FOrg,PK_Group,NC_PK_Org,NC_Modifiedtime";
if (where != null)
{
List<Organization> t = conn.MultiQuery<List<Organization>>(tableName)
.Fields(fields)
.Where(where)
.Execute();
return t;
}
else
{
List<Organization> t = conn.MultiQuery<List<Organization>>(tableName)
.Fields(fields)
.Execute();
return t;
}
}
public TUpdate()
{
this.sql = new StringBuilder();
tfrom = new TFrom(sql);
this.twhere = new TWhere(sql);
}
public TUpdate(StringBuilder sb)
{
this.sql = sb;
tfrom = new TFrom(sql);
this.twhere = new TWhere(sql);
}
internal List<PersonCore> GetPersonCore(IDbConnection conn, IWhere where = null)
{
string tableName = "PersonCore";
string fields = "PK_User,Code,Name,ShortName,IDCardNumber,Sex,Age,Email,Mobile,Birthdate,JoinWorkDate,Censusaddr,NC_PK_User,NC_Modifiedtime";
if (where != null)
{
List<PersonCore> t = conn.MultiQuery<List<PersonCore>>(tableName)
.Fields(fields)
.Where(where)
.Execute();
return t;
}
else
{
List<PersonCore> t = conn.MultiQuery<List<PersonCore>>(tableName)
.Fields(fields)
.Execute();
return t;
}
}
public TCondition()
{
this.sql = new StringBuilder();
twhere = new TWhere(sql);
}
public virtual ISqlQuery AddWhereOr(IWhere condition)
{
MergeWhere(condition, JoinType.Or);
return this;
}
private static void ApplyLike(IWhere where)
{
var text = where.Parameter.Value as string;
if (string.IsNullOrEmpty(text) || text.Contains("%")) return;
if (where.Operator == OperatorType.Like) where.Parameter.Value = string.Format(CultureInfo.InvariantCulture, "%{0}%", text);
else if (where.Operator == OperatorType.LikeLeft) where.Parameter.Value = string.Format(CultureInfo.InvariantCulture, "%{0}", text);
else if (where.Operator == OperatorType.LikeRight) where.Parameter.Value = string.Format(CultureInfo.InvariantCulture, "{0}%", text);
}
internal List<Department> GetDepartment(IDbConnection conn, IWhere where = null)
{
string tableName = "Department";
string fields = "PK_Dept,InnerCode,Name,PK_FDept,PK_Org,PK_Group,NC_PK_Dept,NC_Modifiedtime";
if (where != null)
{
List<Department> t = conn.MultiQuery<List<Department>>(tableName)
.Fields(fields)
.Where(where)
.Execute();
return t;
}
else
{
List<Department> t = conn.MultiQuery<List<Department>>(tableName)
.Fields(fields)
.Execute();
return t;
}
}
/// <summary>
/// 条件
/// </summary>
/// <param name="expression">条件表达式</param>
/// <returns></returns>
public UpdateExecutor Where(IWhere expression)
{
this.expressions = expression.GetExpression();
this.parameters.AddRange(expression.GetParameters());
return this;
}
public TFrom()
{
sql = new StringBuilder();
twhere = new TWhere(sql);
tcondition = new TCondition(sql);
}
public TSelect(StringBuilder sb,IFrom tf,IWhere tw)
{
this.sql = sb;
this.tfrom = tf;
this.twhere = tw;
}
public TSelect()
{
sql = new StringBuilder();
twhere = new TWhere(sql);
tfrom = new TFrom(sql);
}
public TFrom(StringBuilder sb)
{
this.sql = sb;
this.twhere = new TWhere(sb);
tcondition = new TCondition(sb);
}
/// <summary>
/// Adds a condition to the "Where" property, and returns self for chainability
/// </summary>
/// <param name="condition"></param>
/// <param name="conditionType"></param>
/// <returns></returns>
protected void MergeWhere(IWhere component, JoinType joinType)
{
IWhereClause compound = whereClause as IWhereClause;
if (joinType == JoinType.Or && compound != null && compound.Count == 0)
{
throw new Exception("There is no existing condition to OR");
}
if (whereClause is IWhereClause && compound.JoinType == joinType)
{
compound.Add(component);
}
else
{
// currently just a single criterion
whereClause = new WhereClause(joinType, whereClause, component);
}
Touch();
}
/// <summary>
/// Clears all criteria. This does not clear the field map.
/// </summary>
public virtual void Clear()
{
QueryType = QueryType.Select;
Select = "*";
From = "";
GroupBy = "";
parameterList = null;
if (_sortCriterionList.IsValueCreated)
{
sortCriterionList.Clear();
}
parameterCount = 0;
_whereClause = null;
Clean();
}
public virtual IWhereClause Add(IWhere condition, JoinType joinType)
{
MergeWhere(condition, joinType);
return this;
}
private string ParseWhere(string format, IWhere where)
{
string parameter;
if (where.Parameter.Type == ParameterType.Query)
{
parameter = string.Format(CultureInfo.InvariantCulture, "({0})", Parse(where.Parameter.Value as IAdfQuery)); // parse inner query
}
else if (where.Parameter.Type == ParameterType.ValueList)
{
var names = String.Join(",",
((IEnumerable) where.Parameter.Value).Cast<object>().Select((v, i) => string.Format("@{0}_v{1}", where.Parameter.Name, i)).ToArray());
// when list is empty this clause should not return results
if (string.IsNullOrEmpty(names)) return string.Format(CultureInfo.InvariantCulture, format, 1, "=", 0, where.Predicate, "", "");
parameter = string.Format(CultureInfo.InvariantCulture, "({0})", names);
}
else
{
parameter = (where.Parameter.Type == ParameterType.Column)
? ((IColumn) where.Parameter.Value).FullName()
: string.Format(CultureInfo.InvariantCulture, "@{0}", where.Parameter.Name);
if (where.Operator == OperatorType.IsNotEqualOrIsNull)
{
// Surround this clause with brackets
where.OpenBracket++;
where.CloseBracket++;
// Add the check on NULL so that also records that are NULL are returned
parameter += string.Format(CultureInfo.InvariantCulture, " OR {0} IS NULL", where.Column.FullName());
}
}
// NULL and NOT NULL are rendered different and dont use a parameter
if (where.Operator == OperatorType.IsNull || where.Operator == OperatorType.IsNotNull)
{
parameter = null;
}
return string.Format(CultureInfo.InvariantCulture,
format,
where.Column.FullName(),
where.Operator.Value,
parameter,
where.Predicate,
"".PadLeft(where.OpenBracket, '('),
"".PadLeft(where.CloseBracket, ')'));
}
/// <summary>
/// Adds a condition to the "Where" property, and returns self for chainability
/// </summary>
/// <param name="condition"></param>
/// <param name="conditionType"></param>
/// <returns></returns>
protected void MergeWhere(IWhere item, JoinType joinType)
{
if (ReferenceEquals(item, this))
{
throw new ArgumentException("You're trying to add a where clause to itself.");
}
if (JoinType == joinType || IsEmpty)
{
AddImpl(item);
}
else
{
// currently just a single criterion
var clause = new WhereClause(joinType, this.Clone(), item);
_InnerList = clause.InnerList;
JoinType = joinType;
}
Touch();
}
protected void ProcessParameters(IEnumerable<object> parameters)
{
List<string> parmNames = new List<string>(SqlQueryUtility.GetParameterNames(Query));
var parms = new List<object>(UnwrapParameters(parameters));
_Parameters = new List<IDataParameter>();
var interim = new List<object>();
if (parms.Count == 0)
{
return;
}
ParameterMode mode = 0;
int index;
for (index = 0; index < parms.Count; index++)
{
object cur = parms[index];
if (cur is IQSqlDirectiveType)
{
IsStoredProcedure = (IQSqlDirectiveType)cur == IQSqlDirectiveType.StoredProcedure ? true : false;
}
else if (cur is IDataParameter)
{
if (mode != 0 && mode != ParameterMode.KVPs)
{
throw new ArgumentException("An IDataParameter was found after a value-typed parameter. You can't mix parameter types.");
}
_Parameters.Add((IDataParameter)cur);
}
else if (!IsParameterType(cur))
{
// An object; treat it's properties as key/value pairs
if (mode != 0 && mode != ParameterMode.KVPs)
{
throw new ArgumentException("An object parameter was found after a value-typed parameter. To map object properties " +
"as parameters, only objects can be passed.");
}
mode = ParameterMode.KVPs;
foreach (var kvp in GetProperties(cur))
{
int parmIndex = parmNames.IndexOf(CleanParmName(kvp.Key), IQ.Config.ParmNameComparer);
if (parmIndex >= 0)
{
//Use name from the list of parms to ensure proper case
_Parameters.Add(CreateParameter(parmNames[parmIndex], kvp.Value));
}
}
}
else
{
if (mode != 0 && mode != ParameterMode.Mapped)
{
throw new ArgumentException("Can't mix parameter types.");
}
mode = ParameterMode.Mapped;
interim.Add(cur);
}
}
// now address interim parameters, if any
if (interim.Count > 0)
{
bool isNamed = false;
if ((interim.Count % 2) == 0)
{
isNamed = true;
List<IDataParameter> tempList = new List<IDataParameter>();
for (int i = 0; i < interim.Count; i += 2)
{
var val = interim[i];
if (val!=null && interim[i].GetType() == typeof(string))
{
string parmName = (string)interim[i];
// Don't check parm name list for stored procedures
if (!IsStoredProcedure)
{
int parmIndex = parmNames.IndexOf(CleanParmName(parmName), IQ.Config.ParmNameComparer);
if (parmIndex >= 0)
{
tempList.Add(CreateParameter(parmNames[parmIndex], interim[i + 1]));
}
else
{
isNamed = false;
break;
}
}
else
{
tempList.Add(CreateParameter((string)interim[i], interim[i + 1]));
}
}
else
{
isNamed = false;
break;
}
}
if (isNamed)
{
_Parameters.AddRange(tempList);
return;
}
}
// Final type of query to parse: a field name passed with a single parameter. If there are no spaces,
// no parameters in the query, and one parm passed, make it an "equals"
else if (!IsStoredProcedure && interim.Count == 1
&& parmNames.Count == 0
&& Query.IndexOfAny(new char[] {' ','='})<=0)
{
WhereClause = QueryBuilder.WhereEquals(Query, interim[0]);
//Query = Query + "=@val";
//_Parameters.Add(CreateParameter("@val", interim[0]));
return;
}
if (!IsStoredProcedure)
{
// Final validation: if #s match, make a query
if (interim.Count == parmNames.Count)
{
for (int i = 0; i < interim.Count; i++)
{
_Parameters.Add(CreateParameter(parmNames[i], interim[i]));
}
return;
}
else
{
string names = String.Join(",", parmNames);
string values = String.Join(",", interim);
throw new ArgumentException(String.Format("Parameters must match the query parameter names or count. Names: [{0}] Values: [{1}]", names, values));
}
}
} else {
if (_Parameters.Count != parmNames.Count) {
string names = String.Join(",", parmNames);
string values = String.Join(",", _Parameters.Select(item=>item.ParameterName));
throw new ArgumentException(String.Format("Parameters must match the query parameter names or count. Names: [{0}] Values: [{1}]", names, values));
}
}
}
public TCondition(StringBuilder sb)
{
this.sql = sb;
twhere = new TWhere(sb);
}
