protected void ParseProcParams(DataStoredProcedure inputData, Function outputFunc)
{
string paramString = inputData.param_list;
if (string.IsNullOrEmpty(paramString))
{
//nothing to parse
}
else
{
string[] parts = paramString.Split(',');
foreach (string part in parts) //part='OUT param1 int'
{
DbLinq.Schema.Dbml.Parameter paramObj = ParseParameterString(part);
if (paramObj != null)
{
outputFunc.Parameters.Add(paramObj);
}
}
}
if (!string.IsNullOrEmpty(inputData.returns))
{
var paramRet = new Return();
paramRet.DbType = inputData.returns;
paramRet.Type = ParseDbType(null, inputData.returns);
outputFunc.Return = paramRet;
}
}
protected virtual ParameterDefinition GetProcedureParameter(DbLinq.Schema.Dbml.Parameter parameter)
{
var parameterDefinition = new ParameterDefinition();
parameterDefinition.Name = parameter.Name;
parameterDefinition.Type = GetType(parameter.Type, false);
switch (parameter.Direction)
{
case DbLinq.Schema.Dbml.ParameterDirection.In:
parameterDefinition.SpecificationDefinition |= SpecificationDefinition.In;
break;
case DbLinq.Schema.Dbml.ParameterDirection.Out:
parameterDefinition.SpecificationDefinition |= SpecificationDefinition.Out;
break;
case DbLinq.Schema.Dbml.ParameterDirection.InOut:
parameterDefinition.SpecificationDefinition |= SpecificationDefinition.Ref;
break;
default:
throw new ArgumentOutOfRangeException();
}
parameterDefinition.Attribute = NewAttributeDefinition <ParameterAttribute>();
parameterDefinition.Attribute["Name"] = parameter.Name;
parameterDefinition.Attribute["DbType"] = parameter.DbType;
return(parameterDefinition);
}
protected virtual void WriteProcedureBodyOutParameter(CodeWriter writer, DbLinq.Schema.Dbml.Parameter parameter, string result, int parameterIndex, GenerationContext context)
{
string p = writer.GetMethodCallExpression(writer.GetMemberExpression(result, "GetParameterValue"), parameterIndex.ToString());
string cp = writer.GetCastExpression(p, parameter.Type, true);
writer.WriteLine(writer.GetStatement(writer.GetAssignmentExpression(parameter.Name, cp)));
}
/// <summary>
/// parse strings such as 'INOUT param2 INT' or 'param4 varchar ( 32 )'
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
protected DbLinq.Schema.Dbml.Parameter ParseParameterString(string param)
{
param = param.Trim();
var inOut = DbLinq.Schema.Dbml.ParameterDirection.In;
if (param.StartsWith("IN", StringComparison.CurrentCultureIgnoreCase))
{
inOut = DbLinq.Schema.Dbml.ParameterDirection.In;
param = param.Substring(2).Trim();
}
if (param.StartsWith("INOUT", StringComparison.CurrentCultureIgnoreCase))
{
inOut = DbLinq.Schema.Dbml.ParameterDirection.InOut;
param = param.Substring(5).Trim();
}
if (param.StartsWith("OUT", StringComparison.CurrentCultureIgnoreCase))
{
inOut = DbLinq.Schema.Dbml.ParameterDirection.Out;
param = param.Substring(3).Trim();
}
int indxSpace = param.IndexOfAny(new char[] { ' ', '\t' });
if (indxSpace == -1)
{
return(null); //cannot find space between varName and varType
}
string varName = param.Substring(0, indxSpace);
string varType = param.Substring(indxSpace + 1);
DbLinq.Schema.Dbml.Parameter paramObj = new DbLinq.Schema.Dbml.Parameter();
paramObj.Direction = inOut;
paramObj.Name = varName;
paramObj.DbType = varType;
paramObj.Type = ParseDbType(varType);
return(paramObj);
}
/// <summary>
/// parse strings such as 'INOUT param2 INT' or 'param4 varchar ( 32 )'
/// </summary>
/// <param name="paramStr"></param>
/// <returns></returns>
protected DbLinq.Schema.Dbml.Parameter ParseParameterString(string param)
{
param = param.Trim();
var inOut = DbLinq.Schema.Dbml.ParameterDirection.In;
if (param.StartsWith("IN", StringComparison.CurrentCultureIgnoreCase))
{
inOut = DbLinq.Schema.Dbml.ParameterDirection.In;
param = param.Substring(2).Trim();
}
if (param.StartsWith("INOUT", StringComparison.CurrentCultureIgnoreCase))
{
inOut = DbLinq.Schema.Dbml.ParameterDirection.InOut;
param = param.Substring(5).Trim();
}
if (param.StartsWith("OUT", StringComparison.CurrentCultureIgnoreCase))
{
inOut = DbLinq.Schema.Dbml.ParameterDirection.Out;
param = param.Substring(3).Trim();
}
int indxSpace = param.IndexOfAny(new char[] { ' ', '\t' });
if (indxSpace == -1)
return null; //cannot find space between varName and varType
string varName = param.Substring(0, indxSpace);
string varType = param.Substring(indxSpace + 1);
var paramObj = new Parameter();
paramObj.Direction = inOut;
paramObj.Name = varName;
paramObj.DbType = varType;
paramObj.Type = ParseDbType(varName, varType);
return paramObj;
}
Function ParseFunction(DataStoredProcedure pg_proc, Dictionary<long, string> typeOidToName, NameFormat nameFormat)
{
var procedureName = CreateProcedureName(pg_proc.proname, null, nameFormat);
DbLinq.Schema.Dbml.Function dbml_func = new Function();
dbml_func.Name = procedureName.DbName;
dbml_func.Method = procedureName.MethodName;
if (pg_proc.formatted_prorettype != null && string.Compare(pg_proc.formatted_prorettype, "void") != 0)
{
var dbml_param = new Return();
dbml_param.DbType = pg_proc.formatted_prorettype;
dbml_param.Type = MapDbType(null, new DataType { SqlType = pg_proc.formatted_prorettype }).ToString();
dbml_func.Return = dbml_param;
dbml_func.IsComposable = true;
}
if (pg_proc.proallargtypes != null)
{
string[] argModes = parseCsvString(pg_proc.proargmodes);
string[] argNames = parseCsvString(pg_proc.proargnames);
string[] argTypes1 = parseCsvString(pg_proc.proallargtypes); //eg. {23,24,1043}
List<long> argTypes2 = (from t in argTypes1 select long.Parse(t)).ToList();
if (argNames == null)
{
//proc was specified as 'FUNCTION doverlaps(IN date)' - names not specified
argNames = new string[argTypes1.Length];
for (int i = 0; i < argNames.Length; i++) { argNames[i] = ((char)('a' + i)).ToString(); }
}
bool doLengthsMatch = (argTypes2.Count != argNames.Length
|| (argModes != null && argModes.Length != argNames.Length));
if (doLengthsMatch)
{
WriteErrorLine("L238 Mistmatch between modesArr, typeArr and nameArr for func " + pg_proc.proname);
return null;
}
for (int i = 0; i < argNames.Length; i++)
{
DbLinq.Schema.Dbml.Parameter dbml_param = new Parameter();
long argTypeOid = argTypes2[i];
dbml_param.DbType = typeOidToName[argTypeOid];
dbml_param.Name = argNames[i];
dbml_param.Type = MapDbType(argNames[i], new DataType { SqlType = dbml_param.DbType }).ToString();
string inOut = argModes == null ? "i" : argModes[i];
dbml_param.Direction = ParseInOut(inOut);
dbml_func.Parameters.Add(dbml_param);
}
}
return dbml_func;
}
protected override void LoadStoredProcedures(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat)
{
var parameters = ReadParameters(conn, schemaName.DbName);
foreach (var parameter in parameters)
{
var procedureName = CreateProcedureName(parameter.ProcedureName, parameter.Schema, nameFormat);
Function function = schema.Functions.SingleOrDefault(f => f.Method == procedureName.MethodName);
if (function == null)
{
function = new Function { Name = procedureName.DbName, Method = procedureName.MethodName };
schema.Functions.Add(function);
}
if (parameter.Name == null)
{
var returnParameter = new Return();
returnParameter.DbType = parameter.Type.SqlType;
returnParameter.Type = MapDbType(parameter.Name, parameter.Type).ToString();
function.IsComposable = true;
function.Return = returnParameter;
}
else
{
var functionParameter = new Parameter();
functionParameter.DbType = parameter.Type.SqlType;
functionParameter.Type = MapDbType(parameter.Name, parameter.Type).ToString();
if (parameter.In)
{
if (parameter.Out)
functionParameter.Direction = DbLinq.Schema.Dbml.ParameterDirection.InOut;
else
functionParameter.Direction = DbLinq.Schema.Dbml.ParameterDirection.In;
}
else
functionParameter.Direction = DbLinq.Schema.Dbml.ParameterDirection.Out;
var parameterName = CreateParameterName(parameter.Name, nameFormat);
functionParameter.Name = parameterName.CallName;
function.Parameters.Add(functionParameter);
}
}
}
CodeParameterDeclarationExpression GetFunctionParameterType(Parameter parameter)
{
var p = new CodeParameterDeclarationExpression(GetFunctionType(parameter.Type), parameter.Name) {
CustomAttributes = {
new CodeAttributeDeclaration("Parameter",
new CodeAttributeArgument("Name", new CodePrimitiveExpression(parameter.Name)),
new CodeAttributeArgument("DbType", new CodePrimitiveExpression(parameter.DbType))),
},
};
switch (parameter.Direction)
{
case DbLinq.Schema.Dbml.ParameterDirection.In:
p.Direction = FieldDirection.In;
break;
case DbLinq.Schema.Dbml.ParameterDirection.Out:
p.Direction = FieldDirection.Out;
break;
case DbLinq.Schema.Dbml.ParameterDirection.InOut:
p.Direction = FieldDirection.In | FieldDirection.Out;
break;
default:
throw new ArgumentOutOfRangeException();
}
return p;
}
