/// <summary>
/// Gets the meta data DataTable for the routine results schema
/// </summary>
/// <param name="con"></param>
/// <param name="routine"></param>
/// <returns></returns>
protected override DataTable GetSprocResultSchema(DbConnection con, DBSchemaRoutine routine)
{
//some access queries support the analysis, others don't????
string fullname = "SELECT * FROM " + GetFullName(routine.GetReference());
using (DbCommand cmd = this.Database.CreateCommand(con, fullname))
{
cmd.CommandType = CommandType.Text;
if (routine.Parameters.Count > 0)
{
foreach (DBSchemaParameter sp in routine.Parameters)
{
DbParameter param = this.Database.AddCommandParameter(cmd, sp.InvariantName, sp.DbType);
param.Value = DBNull.Value;
param.Direction = sp.Direction;
}
}
using (DbDataReader reader = cmd.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo))
{
DataTable dt = reader.GetSchemaTable();
if (null != dt)
{
WriteCollectionData("Procedures", new string[] { routine.Name }, dt);
}
return(dt);
}
}
}
protected override void FillRoutineParams(DBSchemaRoutine aroutine, DataTable dtSprocParams)
{
DataColumn pos = GetColumn(dtSprocParams, "POSITION", true);
DataColumn direction = GetColumn(dtSprocParams, "IN_OUT", true);
DataColumn isResult = GetColumn(dtSprocParams, "IS_RESULT", false);
DataColumn name = GetColumn(dtSprocParams, "ARGUMENT_NAME", true);
DataColumn type = GetColumn(dtSprocParams, "DATA_TYPE", true);
DataColumn strSize = GetColumn(dtSprocParams, "CHARACTER_LENGTH", false);
DataColumn CharacterSetColumn = GetColumn(dtSprocParams, "CHARACTER_SET_NAME", false);
foreach (DataRow row in dtSprocParams.Rows)
{
DBSchemaParameter param = new DBSchemaParameter();
param.NativeName = GetColumnStringValue(row, name);
param.InvariantName = GetInvariantParameterName(param.NativeName);
param.ParameterIndex = GetColumnIntValue(row, pos, -1);
string dirvalue = GetColumnStringValue(row, direction);
param.Direction = GetParameterDirectionFromSchemaValue(dirvalue);
if (GetColumnBoolValue(row, isResult))
{
param.Direction = ParameterDirection.ReturnValue;
}
param.NativeType = GetColumnStringValue(row, type);
param.DbType = GetDbTypeForNativeType(param.NativeType, GetColumnStringValue(row, CharacterSetColumn));
param.RuntimeType = GetSystemTypeForNativeType(GetColumnStringValue(row, type));
param.ParameterSize = GetColumnIntValue(row, strSize, -1);
aroutine.Parameters.Add(param);
}
}
protected override void FillRoutineData(DBSchemaRoutine aroutine, DataRow dataRow)
{
DataColumn catalog = GetColumn(dataRow.Table, "CATALOG", false);
DataColumn schema = GetColumn(dataRow.Table, "OWNER", false);
DataColumn name = GetColumn(dataRow.Table, "OBJECT_NAME", true);
aroutine.Name = GetColumnStringValue(dataRow, name);
aroutine.Schema = GetColumnStringValue(dataRow, schema);
aroutine.Catalog = GetColumnStringValue(dataRow, catalog);
}
private void GenerateRoutineParameters(DBSchemaRoutine schemaRoutine, bool annotateDirection)
{
if (schemaRoutine.Parameters != null && schemaRoutine.Parameters.Count > 0)
{
List <DBSchemaParameter> param = this.SortColumnsByOrdinal(schemaRoutine.Parameters);
this.BeginBlock();
for (int i = 0; i < param.Count; i++)
{
this.BeginNewLine();
DBSchemaParameter p = param[i];
if (annotateDirection)
{
switch (p.Direction)
{
case System.Data.ParameterDirection.Input:
this.WriteRawSQLString("IN ");
break;
case System.Data.ParameterDirection.InputOutput:
this.WriteRawSQLString("INOUT ");
break;
case System.Data.ParameterDirection.Output:
this.WriteRawSQLString("OUT ");
break;
case System.Data.ParameterDirection.ReturnValue:
//Skip the return parameters
continue;
default:
throw new ArgumentOutOfRangeException("DBSchemaParameter.Direction");
}
}
this.WriteNativeParameterReference(p.InvariantName);
this.WriteSpace();
string options;
string type = this.GetNativeTypeForDbType(p.DbType, p.ParameterSize, -1, DBColumnFlags.Nullable, out options);
this.WriteRawSQLString(type);
if (string.IsNullOrEmpty(options) == false)
{
this.WriteRawSQLString(options);
}
if (i < param.Count - 1)
{
this.WriteReferenceSeparator();
}
}
this.EndBlock();
}
this.BeginNewLine();
}
/// <summary>
/// Populates a routine from the meta data DataTable
/// </summary>
/// <param name="aroutine"></param>
/// <param name="dataRow"></param>
protected override void FillRoutineData(DBSchemaRoutine aroutine, DataRow dataRow)
{
//base.FillRoutineData(aroutine, dataRow);
DataTable dt = dataRow.Table;
DataColumn catalog = GetColumn(dt, "PROCEDURE_CATALOG", false);
DataColumn schema = GetColumn(dt, "PROCEDURE_SCHEMA", false);
DataColumn name = GetColumn(dt, "PROCEDURE_NAME", true);
DataColumn definition = GetColumn(dt, "PROCEDURE_DEFINITION", false);
aroutine.Catalog = GetColumnStringValue(dataRow, catalog);
aroutine.Schema = GetColumnStringValue(dataRow, schema);
aroutine.Name = GetColumnStringValue(dataRow, name);
}
protected override DataTable GetSprocResultSchema(DbConnection con, DBSchemaRoutine routine)
{
//Doesn't support the CommandBehaviour of SchemaOnly
return(null);
string fullname = GetFullName(routine.GetReference());
Query.DBExecQuery exec = Query.DBQuery.Exec(routine.Schema, routine.Name);
foreach (DBSchemaParameter p in routine.Parameters)
{
Query.DBParam qp = Query.DBParam.Param(p.InvariantName, p.DbType, p.Direction);
exec.WithParam(qp);
}
using (DbCommand cmd = this.Database.CreateCommand(con, exec))
{
using (DbDataReader reader = cmd.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo))
{
DataTable dt = reader.GetSchemaTable();
return(dt);
}
}
}
protected override DataTable GetSprocResultSchema(DbConnection con, DBSchemaRoutine routine)
{
return(null); //Doesn't support the SchemaOnly option on the command
}
/// <summary>
/// Ignored
/// </summary>
/// <param name="aroutine"></param>
/// <param name="dtSprocParams"></param>
protected override void FillRoutineParams(DBSchemaRoutine aroutine, DataTable dtSprocParams)
{
//Do Nothing as parameter inspeciton is not supported
}
