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);
}
}
}
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 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;
}
}
