public void CaseSensitivity() { IQ.Config.IgnoreCaseParameters = false; var sql="select * FROM table where col = @Parm1"; var pp = new ParameterParser(sql, "p1value"); Assert.AreEqual(pp.Parameters[0].ParameterName, "@Parm1"); Assert.AreEqual(pp.Parameters[0].Value, "p1value"); Assert.Throws<ArgumentException>(() => { pp = new ParameterParser(sql, "@parm1",123); }); Assert.Throws<ArgumentException>(() => { pp = new ParameterParser(sql, new { parm1=123 }); }); IQ.Config.IgnoreCaseParameters = true; pp = new ParameterParser(sql, "@parm1",123); Assert.AreEqual(pp.Parameters[0].ParameterName, "@Parm1"); Assert.AreEqual(pp.Parameters[0].Value, 123); }
public void NullValues() { ParameterParser pp = new ParameterParser("select * FROM table where col = @parm1", 1); Assert.AreEqual(1, pp.Parameters.Count); Assert.AreEqual(1, pp.Parameters[0].Value); // need 2 parms - null values after the first parameter are considered. Assert.Throws<ArgumentException>(() => { pp = new ParameterParser("select * FROM animals where age = @parm1 and age = @parm2", 1); }); }
public void ExtraData() { string sql = "select * FROM table where col = @parm1, col2 = @parm2"; Assert.Throws<ArgumentException>(() => { var pp = new ParameterParser(sql, new {parm2="p2value", parm1="p1value"},null); }); var pp2= new ParameterParser(sql, new { parm2 = "p2value", parm1 = "p1value" }); Assert.AreEqual(2, pp2.Parameters.Count); }
/// <summary> /// When passing type=0, it's never going to try to build a query - only fully formed query SQl will work. /// </summary> /// <param name="type"></param> /// <param name="query"></param> /// <param name="parameters"></param> protected void ParseQuery(object query, IEnumerable <object> parameters) { ISqlQuery outputQuery = null; if (query == null) { throw new IQMissingQueryException(); } else if (query is SqlQueryMaker) { ExpectNoParameters(parameters); if (QueryType != 0 && ((SqlQueryMaker)query).QueryType != QueryType) { throw new IQException("The query passed was not of type '" + QueryType.ToString() + "' as required for this operation."); } outputQuery = (SqlQueryMaker)query; } else if (QueryType != 0) { outputQuery = ParseComplexQuery(query, parameters); } else if (query is string) { string queryString = (string)query; ParameterParser pp = new ParameterParser(queryString, parameters); outputQuery = new SqlQueryDef(queryString, pp.Parameters); } else { throw new IQException("The type of object '" + query.GetType().ToString() + "' passed as a query isn't something I know how to handle."); } if (outputQuery == null) { throw new IQMissingQueryException(); } if (outputQuery.QueryType == QueryType.Invalid && QueryType != 0) { throw new IQException("Couldn't make a valid query out of the mess you passed me. Check the SQL and the parameters."); } Query = outputQuery; }
public SqlQueryDef(string sql, IEnumerable<object> parameters) { IEnumerable<IDataParameter> parms; if (parameters is IEnumerable<IDataParameter>) { parms = (IEnumerable<IDataParameter>)parameters; QuerySql = sql; } else { ParameterParser pp = new ParameterParser(sql, parameters); QuerySql = pp.GetQuery(); parms = pp.Parameters; } QueryParameters.AddRange(parms); }
public void SimpleQueries() { string sql = "select * FROM table where col = @parm1, col2 = @parm2"; var pp = new ParameterParser(sql, 1,"something"); Action sameTest = () => { var p1 = pp.Parameters.FirstOrDefault(item => item.ParameterName == "@parm1"); var p2 = pp.Parameters.FirstOrDefault(item => item.ParameterName == "@parm2"); Assert.AreEqual(2, pp.Parameters.Count); Assert.AreEqual(1, p1.Value); Assert.AreEqual("something", p2.Value); }; sameTest(); pp = new ParameterParser(sql, "parm2", "something", "parm1", 1); sameTest(); pp = new ParameterParser(sql, new { parm1= 1, parm2= "something" }); sameTest(); pp = new ParameterParser(sql, new { parm1= 1, },new { parm2= "something" }); sameTest(); }
protected ISqlQuery ParseComplexQuery(object query, IEnumerable <object> parms) { ISqlQuery outputQuery = null; // We always want to parse the parameters. But if the thing passed to us as "query" is not a string, then // just assume that all the parms are option type parameters and don't pass a query to ParameterParser string querySource = query is string? (string)query: ""; ParameterParser pp = new ParameterParser(querySource, parms); if (Types.IsNumericType(query)) { // It's a single numeric value - assume it's a primary key ExpectNoParameters(pp.Parameters); var classInfo = IQ.ClassInfo <T>(); ISqlQueryMaker queryPK = classInfo.GetQuery(); queryPK.Where.Add(classInfo.PrimaryKeyField.Name, query); outputQuery = queryPK; } else if (query is string) { bool isMappable = Types.IsMappable(typeof(T)); // First check if its a single named field if (isMappable) { var classInfo = IQ.ClassInfo <T>(); // Try to create a valid raw query.. if it's not valid, assume it's a where if (QueryType == QueryType.Where || pp.QueryType == QueryType.Invalid) { ISqlQueryMaker queryPK = classInfo.GetQuery(); //var whereString = new WhereString(pp.Query, // pp.Parameters.Count > 0 ? // pp.Parameters.ToArray(): // null); queryPK.Where.Add(pp.GetWhereClause()); outputQuery = queryPK; } else { outputQuery = new SqlQueryDef(pp.GetQuery(QueryType), pp.Parameters); } } else { // it's mapped to a primitive type - outputQuery = new SqlQueryDef(pp.GetQuery(QueryType), pp.Parameters); } } if (outputQuery.QueryType != QueryType) { throw new IQException("Wrong type of query passed to method: was " + outputQuery.ToString() + ", expected " + QueryType.ToString()); } return(outputQuery); }
/// <summary> /// Build a where clause from a string /// </summary> /// <param name="clause"></param> /// <param name="parameters"></param> /// <returns></returns> public static IWhere WhereParse(string clause, params object[] parameters) { ParameterParser parser = new ParameterParser(clause, parameters); return new WhereString(clause, parser.Parameters.ToArray()); }