public bool Feild(uint k, Sio.SDataBuff v)
{
ParamKey t = (ParamKey)k;
switch (t)
{
case ParamKey.param_key_name:
name = v.stringValue;
break;
case ParamKey.param_key_type_name:
typeName = v.stringValue;
break;
case ParamKey.param_key_type:
dtype = (ParamType)v.intValue;
break;
case ParamKey.param_key_container:
container = (ParamContainer)v.intValue;
break;
case ParamKey.param_key_id:
id = v.intValue;
break;
case ParamKey.param_key_is_list:
isList = v.boolValue;
break;
default:
return(false);
}
return(true);
}
public string ToStringExt(string[] acceptedParams, bool hideKeyName = false, bool ignoreOptions = false)
{
var txt = new List <string>();
//
var flagForERROR = false;
if (acceptedParams != null)
{
flagForERROR = true;
if (ParamKey.Equals(AppParams.HIDDEN_PARAM_01, StringComparison.CurrentCultureIgnoreCase))
{
flagForERROR = false;
}
else
{
foreach (var acceptedParam in acceptedParams)
{
if (ParamKey.Equals(acceptedParam, StringComparison.CurrentCultureIgnoreCase))
{
flagForERROR = false;
break;
}
}
}
}
//
if (!hideKeyName)
{
if (flagForERROR)
{
// do not change "Not a valid parameter" right now as it's hardcoded twice in the app
txt.Add($"\tParamKey: {ParamKey} Not a valid parameter!");
}
else
{
txt.Add($"\tParamKey: {ParamKey}");
}
}
//
if (!ignoreOptions)
{
if (ParamData == null)
{
txt.Add($"\t\tParamData: null");
}
else
{
txt.Add($"\t\tParamData: {ParamData.Count} rows");
foreach (var itm in ParamData)
{
txt.Add($"\t\t\t{itm}");
}
}
}
//
return(string.Join("\r\n", txt));
}
public bool isParamKey(string paramTXT)
{
if (paramTXT == null)
{
return(false);
}
if (ParamKey == null)
{
return(false);
}
if (!ParamKey.StartsWith("-") && !ParamKey.StartsWith("/"))
{
return(false);
}
var ret = normalizeParamKey(paramTXT).Equals(normalizeParamKey(ParamKey), StringComparison.OrdinalIgnoreCase);
return(ret);
}
public ParamHandler(DbProvider dbProvider, string sql, CommandType commandType)
{
_paramKeys = new List <ParamKey>();
_dbProvider = dbProvider;
_sql = sql;
CommandType = commandType;
var regex = new Regex(@"[#\$]([\s\S]*?)[#\$]", RegexOptions.IgnoreCase | RegexOptions.Multiline);
var ms = regex.Matches(sql);
foreach (Match item in ms)
{
if (item.Groups.Count > 0 && !string.IsNullOrEmpty(item.Groups[1].Value))
{
var v1 = item.Value;
var v2 = item.Groups[1].Value;
var v3 = v1.StartsWith("#") ? "#" : "$";
ParamKey k = new ParamKey(v1, v2, v3);
_paramKeys.Add(k);
}
}
}
private static DataParameter[] GetDataParameters(DataConnection dataConnection, object parameters)
{
if (parameters == null)
{
return(null);
}
var dataParameters = parameters as DataParameter[];
if (dataParameters != null)
{
return(dataParameters);
}
var parameter = parameters as DataParameter;
if (parameter != null)
{
return new[] { parameter }
}
;
Func <object, DataParameter[]> func;
var type = parameters.GetType();
var key = new ParamKey(type, dataConnection.ID);
if (!_parameterReaders.TryGetValue(key, out func))
{
var td = dataConnection.MappingSchema.GetEntityDescriptor(type);
var p = Expression.Parameter(typeof(object), "p");
var obj = Expression.Parameter(parameters.GetType(), "obj");
var expr = Expression.Lambda <Func <object, DataParameter[]> >(
Expression.Block(
new[] { obj }, Expression.Assign(obj, Expression.Convert(p, type)), Expression.NewArrayInit(
typeof(DataParameter),
td.Columns.Select(m =>
{
if (m.MemberType == typeof(DataParameter))
{
var pobj = Expression.Parameter(typeof(DataParameter));
return(Expression.Block(
new[] { pobj },
Expression.Assign(pobj, Expression.PropertyOrField(obj, m.MemberName)),
Expression.MemberInit(
Expression.New(typeof(DataParameter)),
Expression.Bind(
_dataParameterName,
Expression.Coalesce(
Expression.MakeMemberAccess(pobj, _dataParameterName),
Expression.Constant(m.ColumnName))),
Expression.Bind(
_dataParameterDataType,
Expression.MakeMemberAccess(pobj, _dataParameterDataType)),
Expression.Bind(
_dataParameterValue,
Expression.Convert(
Expression.MakeMemberAccess(pobj, _dataParameterValue),
typeof(object))))));
}
var memberType = m.MemberType.ToNullableUnderlying();
var valueGetter = Expression.PropertyOrField(obj, m.MemberName) as Expression;
var mapper = dataConnection.MappingSchema.GetConvertExpression(memberType,
typeof(DataParameter), createDefault: false);
if (mapper != null)
{
return(Expression.Call(
MemberHelper.MethodOf(() => PrepareDataParameter(null, null)),
mapper.GetBody(valueGetter),
Expression.Constant(m.ColumnName)));
}
if (memberType.IsEnum)
{
var mapType =
ConvertBuilder.GetDefaultMappingFromEnumType(dataConnection.MappingSchema,
memberType);
var convExpr = dataConnection.MappingSchema.GetConvertExpression(m.MemberType,
mapType);
memberType = mapType;
valueGetter = convExpr.GetBody(valueGetter);
}
return((Expression)Expression.MemberInit(
Expression.New(typeof(DataParameter)),
Expression.Bind(
_dataParameterName,
Expression.Constant(m.ColumnName)),
Expression.Bind(
_dataParameterDataType,
Expression.Constant(
dataConnection.MappingSchema.GetDataType(memberType).DataType)),
Expression.Bind(
_dataParameterValue,
Expression.Convert(valueGetter, typeof(object)))));
}))),
p);
_parameterReaders[key] = func = expr.Compile();
}
return(func(parameters));
}
public Param(ParamKey key, long value)
{
Key = key.ToString();
Value = Convert.ToString(value);
}
public Param(ParamKey key, string value)
{
Key = key.ToString();
Value = value;
}
