/// <summary>
/// Reads a table and inject it as a tuple set in OPL.
/// </summary>
/// <param name="name">The name of the Data Set</param>
/// <param name="reader">The SqlDataReader to read from</param>
private void ReadTupleSet(String name, DbDataReader reader)
{
OplDataHandler handler = DataHandler;
OplElement element = handler.getElement(name);
ITupleSchema schema = element.AsTupleSet().Schema;
int size = schema.Size;
String[] oplFieldsName = new String[size];
OplElementDefinitionType.Type[] oplFieldsType = new OplElementDefinitionType.Type[size];
this.FillNamesAndTypes(schema, oplFieldsName, oplFieldsType);
handler.StartElement(name);
handler.StartSet();
while (reader.Read())
{
handler.StartTuple();
for (int column = 0; column < oplFieldsName.Length; column++)
{
String columnName = oplFieldsName[column];
HandleColumnValue(handler, oplFieldsType[column], reader[columnName]);
}
handler.EndTuple();
}
handler.EndSet();
}
/// <summary>
/// Returns a table definition from an OPL tuple schema.
///
/// The table definition is an array of N strings, each describing an element of the tuple.
/// </summary>
/// <param name="tupleSchema">The OPL Tuple schema</param>
/// <param name="includeType">If True, The table definition has the form "NAME TYPE" otherwise just "NAME"</param>
/// <returns>The table definition</returns>
private String[] TableDefinitionFromOplTupleSchema(ITupleSchema tupleSchema, bool includeType)
{
OplElementDefinition elementDefinition = this.Model.ModelDefinition.getElementDefinition(tupleSchema.Name);
OplTupleSchemaDefinition oplTupleSchema = elementDefinition.asTupleSchema();
String[] fields = new String[tupleSchema.Size];
for (int i = 0; i < tupleSchema.Size; i++)
{
String columnName = tupleSchema.GetColumnName(i);
String field = columnName;
if (includeType)
{
OplElementDefinitionType.Type oplType = oplTupleSchema.getComponent(i).getElementDefinitionType();
String sqlType = null;
if (oplType == OplElementDefinitionType.Type.INTEGER)
{
sqlType = "INT";
}
else if (oplType == OplElementDefinitionType.Type.FLOAT)
{
sqlType = "FLOAT";
}
else if (oplType == OplElementDefinitionType.Type.STRING)
{
sqlType = "VARCHAR(30)";
}
field += " " + sqlType;
}
fields[i] = field;
}
return(fields);
}
private void InsertIntoTable(DbConnection con, ITupleSchema tupleSchema, ITuple tuple, string insertCommand)
{
OplElementDefinition elementDefinition = this.Model.ModelDefinition.getElementDefinition(tupleSchema.Name);
OplTupleSchemaDefinition tupleDef = elementDefinition.asTupleSchema();
using (DbCommand insert = con.CreateCommand())
{
insert.CommandText = insertCommand;
for (int i = 0; i < tupleSchema.Size; i++)
{
OplElementDefinitionType.Type oplType = tupleDef.getComponent(i).getElementDefinitionType();
object oplValue = null;
if (oplType == OplElementDefinitionType.Type.INTEGER)
{
oplValue = tuple.GetIntValue(i);
}
else if (oplType == OplElementDefinitionType.Type.FLOAT)
{
oplValue = tuple.GetNumValue(i);
}
else if (oplType == OplElementDefinitionType.Type.STRING)
{
oplValue = tuple.GetStringValue(i);
}
DbUtils.AddParameterWithValue(insert, "@value" + i, oplValue);
}
insert.ExecuteNonQuery();
}
}
/// <summary>
/// Reads a table and inject the value as a Set in OPL.
/// </summary>
/// <param name="type">The type of the Set elements</param>
/// <param name="name">The name of the Set</param>
/// <param name="reader">The SqlDataReader to read from</param>
private void ReadSet(OplElementDefinitionType.Type type, String name, DbDataReader reader)
{
OplDataHandler handler = DataHandler;
handler.StartElement(name);
handler.StartSet();
while (reader.Read())
{
HandleColumnValue(handler, type, reader.GetValue(0));
}
handler.EndSet();
}
/// <summary>
/// Add a new item (field) to the Set currently in the Data handler.
///
/// The value of the field is converted and added depending on fieldType.
/// </summary>
/// <param name="handler">The OPL data handler</param>
/// <param name="fieldType">The type of the field to add</param>
/// <param name="value">The value to convert</param>
private void HandleColumnValue(OplDataHandler handler, OplElementDefinitionType.Type fieldType, object value)
{
if (fieldType == OplElementDefinitionType.Type.INTEGER)
{
handler.AddIntItem(Convert.ToInt32(value));
}
else if (fieldType == OplElementDefinitionType.Type.FLOAT)
{
handler.AddNumItem(Convert.ToDouble(value));
}
else if (fieldType == OplElementDefinitionType.Type.STRING)
{
handler.AddStringItem(Convert.ToString(value));
}
}
/// <summary>
/// Reads the set or tuple from the specified data reader.
/// </summary>
/// <param name="name">set or tuple name.</param>
/// <param name="reader">data source.</param>
private void ReadSetOrTuple(String name, DbDataReader reader)
{
OplElementDefinition def = this.modelDefinition.getElementDefinition(name);
OplElementDefinitionType.Type type = def.getElementDefinitionType();
OplElementDefinitionType.Type leaf = def.getLeaf().getElementDefinitionType();
if (type == OplElementDefinitionType.Type.SET)
{
if (leaf == OplElementDefinitionType.Type.TUPLE)
{
this.ReadTupleSet(name, reader);
}
else
{
this.ReadSet(leaf, name, reader);
}
}
}
