/// <summary>
/// Create the ORDER BY-Clause from the preference model
/// </summary>
/// <param name="model"></param>
/// <param name="type"></param>
/// <returns></returns>
public string GetSortClause(PrefSQLModel model, SQLCommon.Ordering type)
{
string strSQL = "";
switch (type)
{
case SQLCommon.Ordering.AttributePosition:
strSQL = GetSortAttributePositionClause(model);
break;
case SQLCommon.Ordering.RankingSummarize:
strSQL = GetSortRankingSumClause(model);
break;
case SQLCommon.Ordering.RankingBestOf:
strSQL = GetSortRankingBestOfClause(model);
break;
case SQLCommon.Ordering.AsIs:
strSQL = ""; //Return no ORDER BY Clause
break;
case SQLCommon.Ordering.Random:
strSQL = GetSortRandomClause();
break;
case SQLCommon.Ordering.EntropyFunction:
{
strSQL = GetSortEntropyValue(model);
break;
}
}
if (strSQL.Length > 0)
{
strSQL = " ORDER BY " + strSQL;
}
return strSQL;
}
/// <summary>
/// Sorts the results according to the attributes values. the first attribute has the highest priority.
/// For example a tuple has the attributes price and color. The result will be sorted after price and color, whereas
/// the price has the higher priority
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private string GetSortEntropyValue(PrefSQLModel model)
{
string strSQL = "";
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
//First record doesn't need a comma to separate
if (iChild > 0)
{
strSQL += " + ";
}
strSQL += model.Skyline[iChild].Expression;
}
return strSQL;
}
/// <summary>
/// Sorts the results according to the attributes values. the first attribute has the highest priority.
/// For example a tuple has the attributes price and color. The result will be sorted after price and color, whereas
/// the price has the higher priority
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private string GetSortAttributePositionClause(PrefSQLModel model)
{
string strSQL = "";
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
//First record doesn't need a comma to separate
if (iChild > 0)
{
strSQL += ", ";
}
//strSQL += model.Skyline[iChild].OrderBy.ToString();
strSQL += model.Skyline[iChild].Expression;
}
return strSQL;
}
/// <summary>
/// Create the WHERE-Clause according to the preference model
/// </summary>
/// <param name="model"></param>
/// <param name="strPreSQL"></param>
/// <returns></returns>
public string GetCriterionClause(PrefSQLModel model, string strPreSQL)
{
//Build Skyline only if more than one attribute
string strSQL = GetCriterionSkylineClause(model, strPreSQL);
//Check if a WHERE-Clause was built
if (strSQL.Length > 0)
{
//Only add WHERE if there is not already a where clause
bool isWherePresent = strPreSQL.IndexOf("WHERE", StringComparison.Ordinal) > 0;
if (isWherePresent)
{
strSQL = " AND " + strSQL;
}
else
{
strSQL = " WHERE " + strSQL;
}
}
return strSQL;
}
/// <summary>
/// Sorts the results according to their summed ranking.
/// For example a tuple has the best, 5th and 7th rank in three attributes. This leads to a ranking of 13.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private string GetSortRankingSumClause(PrefSQLModel model)
{
string strSQL = "";
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
//First attribute doesn't need a plus
if(iChild > 0)
{
strSQL += " + ";
}
string strRankingExpression = "DENSE_RANK() OVER (ORDER BY " + model.Skyline[iChild].Expression + ")";
strSQL += strRankingExpression;
}
return strSQL;
}
/// <summary>
/// Sorts the results according to their best ranking of all attributes
/// For example a tuple has the best, 5th and 7th rank in three attributes. This leads to a ranking of 1.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private string GetSortRankingBestOfClause(PrefSQLModel model)
{
string strSQL = "CASE ";
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
string strRankingExpression = "DENSE_RANK() OVER (ORDER BY " + model.Skyline[iChild].Expression + ")";
strRankingExpression = strRankingExpression.Replace("DENSE_RANK()", "ROW_NUMBER()");
if (model.Skyline.Count == 1)
{
//special case if totally only one preference
strSQL += "WHEN 1=1 THEN " + strRankingExpression + " ";
}
if (iChild == model.Skyline.Count - 1)
{
//Last record only needs ELSE
strSQL += " ELSE " + "" + strRankingExpression;
}
else
{
strSQL += "WHEN ";
string strRanking = strRankingExpression;
for (int iSubChild = iChild + 1; iSubChild < model.Skyline.Count; iSubChild++)
{
string strSubRanking = "DENSE_RANK() OVER (ORDER BY " + model.Skyline[iSubChild].Expression + ")";
strSubRanking = strSubRanking.Replace("DENSE_RANK()", "ROW_NUMBER()");
strSQL += strRanking + " <=" + strSubRanking;
if (iSubChild < model.Skyline.Count - 1)
{
strSQL += " AND ";
}
}
strSQL += " THEN " + strRankingExpression + " ";
}
}
strSQL += " END";
return strSQL;
}
/// <summary>This method is used for Pareto Dominance Grahps. It adds the Skyline Attributes to the SELECT List.</summary>
/// <remarks>
/// For the reason that comparing the values is easier, smaller values are always better than higher.
/// Therefore HIGH preferences are multiplied with -1
/// Every preference gets 2 output values. the 1st declares the level, the second the exact value if an additional comparison
/// is needed, because of incomparability
/// </remarks>
/// <param name="model">model of parsed Preference SQL Statement</param>
/// <returns>Return the extended SQL Statement</returns>
private string GetSelectClauseForSkylineAttributes(PrefSQLModel model)
{
string strSQL = "";
//Build Skyline only if more than one attribute
if (model.Skyline.Count > 0)
{
//Build the where clause with each column in the skyline
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
string strFullColumnName = model.Skyline[iChild].FullColumnName.Replace(".", "_");
strSQL += ", " + model.Skyline[iChild].RankExpression + " AS SkylineAttribute" + strFullColumnName;
//Incomparable field --> Add string field
if (model.Skyline[iChild].Comparable == false)
{
strSQL += ", " + model.Skyline[iChild].IncomparableAttribute + " AS SkylineAttributeIncomparable" + strFullColumnName;
}
}
}
return strSQL;
}
/// <summary>TODO</summary>
/// <param name="model">model of parsed Preference SQL Statement</param>
/// <param name="strOperators">Returns the operators</param>
/// <returns>TODO</returns>
private string BuildSelectHexagon(PrefSQLModel model, out string strOperators)
{
strOperators = "";
string strSQL = "";
//Add a RankColumn for each PRIORITIZE preference
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
//Replace ROW_NUMBER with Rank, for the reason that multiple tuples can have the same value (i.e. mileage=0)
string strRank = model.Skyline[iChild].RankExpression;
strSQL += ", " + strRank;
strOperators += "LOW" + ";";
if (model.Skyline[iChild].Comparable == false && model.Skyline[iChild].AmountOfIncomparables > 0)
{
strSQL += ", " + model.Skyline[iChild].HexagonIncomparable;
if (model.Skyline[iChild].AmountOfIncomparables == 99)
{
strOperators += "CALCULATEINCOMPARABLE;";
}
else
{
//CASE WHEN colors.name IN ('blau') THEN '001' WHEN colors.name IN ('silver') THEN '010' ELSE '100' END AS RankColorNew
for (int iIncomparable = 0; iIncomparable < model.Skyline[iChild].AmountOfIncomparables; iIncomparable++)
{
strOperators += "INCOMPARABLE;";
}
}
}
}
//Add the ranked column before the FROM keyword
strSQL = strSQL.TrimStart(',');
strOperators = strOperators.TrimEnd(';');
return strSQL;
}
/// <summary>
/// Build the WHERE Clause to implement a Skyline
/// </summary>
/// <param name="model"></param>
/// <param name="strPreSQL"></param>
/// <returns></returns>
private string GetCriterionSkylineClause(PrefSQLModel model, string strPreSQL)
{
string strWhereEqual;
string strWhereBetter = " AND ( ";
string strSQL = "";
//Only add WHERE if there is not already a where clause
bool isWherePresent = strPreSQL.IndexOf("WHERE", StringComparison.Ordinal) > 0;
if (isWherePresent)
{
strWhereEqual = " AND ";
}
else
{
strWhereEqual = "WHERE ";
}
//Build the where clause with each column in the skyline
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
//Competition
bool needsTextOrClause = model.Skyline[iChild].IsCategorical;
//First child doesn't need an OR/AND
if (iChild > 0)
{
strWhereEqual += " AND ";
strWhereBetter += " OR ";
}
//Falls Text-Spalte ein zusätzliches OR einbauen für den Vergleich Farbe = Farbe
if (needsTextOrClause)
{
strWhereEqual += "(";
}
strWhereEqual += "{INNERcolumn} <= {column}";
strWhereBetter += "{INNERcolumn} < {column}";
strWhereEqual = strWhereEqual.Replace("{INNERcolumn}", model.Skyline[iChild].InnerExpression);
strWhereBetter = strWhereBetter.Replace("{INNERcolumn}", model.Skyline[iChild].InnerExpression);
strWhereEqual = strWhereEqual.Replace("{column}", model.Skyline[iChild].Expression);
strWhereBetter = strWhereBetter.Replace("{column}", model.Skyline[iChild].Expression);
//Falls Text-Spalte ein zusätzliches OR einbauen für den Vergleich Farbe = Farbe
if (needsTextOrClause)
{
strWhereEqual += " OR " + model.Skyline[iChild].InnerFullColumnName + " = " + model.Skyline[iChild].FullColumnName;
strWhereEqual += ")";
}
}
//closing bracket for 2nd condition
strWhereBetter += ") ";
//Format strPreSQL
foreach (KeyValuePair<string, string> table in model.Tables)
{
//Add ALIAS to tablename (Only if not already an ALIAS was set)
if (table.Value.Equals(""))
{
//Replace tablename (for fields)
strPreSQL = strPreSQL.Replace(table.Key + ".", table.Key + "_INNER.");
string pattern = @"\b" + table.Key + @"\b";
string replace = table.Key + " " + table.Key + "_INNER";
strPreSQL = Regex.Replace(strPreSQL, pattern, replace, RegexOptions.IgnoreCase);
}
else
{
//Replace tablename (for fields)
strPreSQL = Regex.Replace(strPreSQL, @"\b" + table.Value + @"\.", table.Value + "_INNER.", RegexOptions.IgnoreCase);
//Replace ALIAS
string pattern = @"\b" + table.Value + @"\b";
string replace = table.Value + "_INNER";
strPreSQL = Regex.Replace(strPreSQL, pattern, replace, RegexOptions.IgnoreCase);
}
}
//Check if SQL contains TOP Keywords
if (model.NumberOfRecords != 0)
{
//Remove Top Keyword in inner clause
int iPosTop = strPreSQL.IndexOf("TOP", StringComparison.Ordinal);
int iPosTopEnd = strPreSQL.Substring(iPosTop + 3).TrimStart().IndexOf(" ", StringComparison.Ordinal);
string strSQLAfterTop = strPreSQL.Substring(iPosTop + 3).TrimStart();
strPreSQL = strPreSQL.Substring(0, iPosTop) + strSQLAfterTop.Substring(iPosTopEnd + 1);
}
strSQL += "NOT EXISTS(" + strPreSQL + " " + strWhereEqual + strWhereBetter + ")";
return strSQL;
}
/// <summary>TODO</summary>
/// <param name="model">model of parsed Preference SQL Statement</param>
/// <param name="weight"></param>
/// <returns>TODO</returns>
private string BuildIncomparableHexagon(PrefSQLModel model, ref string weight)
{
string strDistinctSelect = "";
//Add a RankColumn for each PRIORITIZE preference
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
//Add additional columns if attribute is incomparable
if (model.Skyline[iChild].Comparable == false && model.Skyline[iChild].AmountOfIncomparables > 0)
{
//strMaxSQL += "+1";
//99 means OTHER INCOMPARABLE --> not clear at the moment how many distinct values exists
if (model.Skyline[iChild].AmountOfIncomparables == 99)
{
strDistinctSelect += model.Skyline[iChild].IncomparableAttribute + ";";
weight += model.Skyline[iChild].HexagonWeightIncomparable.ToString() + ";";
}
}
}
strDistinctSelect = strDistinctSelect.TrimEnd(';');
weight = weight.TrimEnd(';');
return strDistinctSelect;
}
/// <summary>
/// Parses a PREFERENE SQL Statement in an ANSI SQL Statement
/// </summary>
/// <param name="strInput"></param>
/// <param name="prefSQLParam"></param>
/// <returns>Return the ANSI SQL Statement</returns>
/// <exception cref="Exception">This is exception is thrown because the String is not a valid PrefSQL Query</exception>
internal string ParsePreferenceSQL(string strInput, PrefSQLModel prefSQLParam)
{
SQLSort sqlSort = new SQLSort();
SQLCriterion sqlCriterion = new SQLCriterion();
string strSQLReturn = ""; //The SQL-Query that is built on the basis of the prefSQL
PrefSQLModel prefSQL = prefSQLParam ?? GetPrefSqlModelFromPreferenceSql(strInput);
try
{
//Check if parse was successful and query contains PrefSQL syntax
if (prefSQL != null) // && strInput.IndexOf(SkylineOf) > 0
{
if (prefSQL.Skyline.Count > 0)
{
//Mark as incomparable if needed (to choose the correct algorithm)
//withIncomparable = prefSQL.WithIncomparable;
//Add all Syntax before the Skyline-Clause
strSQLReturn = strInput.Substring(0, strInput.IndexOf(SkylineOf, StringComparison.Ordinal) - 1).TrimStart(' ');
//Add Skyline Attributes to select list. This option is i.e. useful to create a dominance graph.
//With help of the skyline values it is easier to create this graph
if (ShowInternalAttributes)
{
//Add the attributes to the existing SELECT clause
string strSQLSelectClause = GetSelectClauseForSkylineAttributes(prefSQL);
string strSQLBeforeFrom = strSQLReturn.Substring(0, strSQLReturn.IndexOf("FROM", StringComparison.Ordinal));
string strSQLAfterFromShow = strSQLReturn.Substring(strSQLReturn.IndexOf("FROM", StringComparison.Ordinal));
strSQLReturn = strSQLBeforeFrom + strSQLSelectClause + " " + strSQLAfterFromShow;
}
//Add ORDER BY Clause
string strOrderBy = "";
if (strInput.IndexOf("ORDER BY", StringComparison.Ordinal) > 0)
{
if (prefSQL.Ordering == Ordering.AsIs)
{
string strTmpInput = strInput;
//Replace category clauses
//Start with latest order by (otherwise substring start, stop position are changed)
for (int iIndex = prefSQL.OrderBy.Count - 1; iIndex >= 0; iIndex--)
{
OrderByModel model = prefSQL.OrderBy[iIndex];
strTmpInput = strTmpInput.Substring(0, model.Start) + model.Text + strTmpInput.Substring(model.Stop);
}
strOrderBy = strTmpInput.Substring(strInput.IndexOf("ORDER BY", StringComparison.Ordinal));
}
else
{
strOrderBy = sqlSort.GetSortClause(prefSQL, prefSQL.Ordering); // sqlSort.getSortClause(prefSQL, _OrderType);
}
//Add space charachter in front of ORDER BY if not already present
if (!strOrderBy.Substring(0, 1).Equals(" "))
{
strOrderBy = " " + strOrderBy;
}
}
////////////////////////////////////////////
//attributes used for native sql algorithm
string strWhere = sqlCriterion.GetCriterionClause(prefSQL, strSQLReturn);
////////////////////////////////////////////
//attributes used for other algorithms
string strOperators;
string strAttributesSkyline = BuildPreferencesBNL(prefSQL, out strOperators);
//Without SELECT
//Remove TOP keyword, expect for the native SQL algorithm
if (prefSQL.NumberOfRecords != 0 && SkylineType.IsNative() == false)
{
//Remove Top Keyword in inner clause
int iPosTop = strSQLReturn.IndexOf("TOP", StringComparison.Ordinal);
int iPosTopEnd = strSQLReturn.Substring(iPosTop + 3).TrimStart().IndexOf(" ", StringComparison.Ordinal);
string strSQLAfterTop = strSQLReturn.Substring(iPosTop + 3).TrimStart();
strSQLReturn = strSQLReturn.Substring(0, iPosTop) + strSQLAfterTop.Substring(iPosTopEnd + 1);
}
string strAttributesOutput = ", " + strSQLReturn.Substring(7, strSQLReturn.IndexOf("FROM", StringComparison.Ordinal) - 7);
string strSQLAfterFrom = strSQLReturn.Substring(strSQLReturn.IndexOf("FROM", StringComparison.Ordinal));
string strFirstSQL = "SELECT " + strAttributesSkyline + " " + strAttributesOutput + strSQLAfterFrom;
if (SkylineType.IsNative())
{
strFirstSQL = strSQLReturn;
}
string strOrderByAttributes = sqlSort.GetSortClause(prefSQL, WindowSort);
////////////////////////////////////////////
//attributes used for hexagon
string[] additionalParameters = new string[6];
string strOperatorsHexagon;
string strAttributesSkylineHexagon = BuildSelectHexagon(prefSQL, out strOperatorsHexagon);
//Without SELECT
//Quote quotes because it is a parameter of the stored procedure
string strFirstSQLHexagon = "SELECT " + strAttributesSkylineHexagon + " " + strAttributesOutput + strSQLAfterFrom;
strFirstSQLHexagon = strFirstSQLHexagon.Replace("'", "''");
//Quote quotes because it is a parameter of the stored procedure
//string strSelectDistinctIncomparable = "";
string weightHexagonIncomparable = "";
string strSelectDistinctIncomparable = BuildIncomparableHexagon(prefSQL, ref weightHexagonIncomparable);
strSelectDistinctIncomparable = strSelectDistinctIncomparable.Replace("'", "''");
additionalParameters[0] = strFirstSQLHexagon;
additionalParameters[1] = strOperatorsHexagon;
additionalParameters[2] = strSelectDistinctIncomparable;
additionalParameters[3] = weightHexagonIncomparable;
_skylineType.SortType = (int)prefSQL.Ordering;
_skylineType.RecordAmountLimit = prefSQL.NumberOfRecords;
_skylineType.MultipleSkylineUpToLevel = _skylineUpToLevel;
_skylineType.AdditionParameters = additionalParameters;
_skylineType.HasIncomparablePreferences = prefSQL.WithIncomparable;
//Now create the query depending on the Skyline algorithm
if (!prefSQL.HasSkylineSample)
{
strSQLReturn = _skylineType.GetStoredProcedureCommand(strWhere, strOrderBy, strFirstSQL,
strOperators, strOrderByAttributes);
}
else
{
var skylineSample = new SkylineSampling
{
SubsetCount = prefSQL.SkylineSampleCount,
SubsetDimension = prefSQL.SkylineSampleDimension,
SelectedStrategy = _skylineType
};
strSQLReturn = skylineSample.GetStoredProcedureCommand(strWhere, strOrderBy, strFirstSQL,
strOperators, strOrderByAttributes);
}
}
if(prefSQL.Ranking.Count > 0)
{
if(prefSQL.ContainsOpenPreference)
{
throw new Exception("WeightedSum cannot handle implicit INCOMPARABLE values. Please add the explicit OTHERS EQUAL to the preference");
}
string strSelectExtremas = "";
string strRankingWeights = "";
string strRankingExpressions = "";
string strColumnNames = "";
// Set the decimal seperator, because prefSQL double values are always with decimal separator "."
NumberFormatInfo format = new NumberFormatInfo();
format.NumberDecimalSeparator = ".";
foreach (RankingModel rankingModel in prefSQL.Ranking)
{
strSelectExtremas += rankingModel.SelectExtrema + ";";
strRankingWeights += rankingModel.Weight.ToString(format) + ";";
strRankingExpressions += rankingModel.Expression + ";";
strColumnNames += rankingModel.FullColumnName.Replace(".", "_") + ";";
}
strSelectExtremas = strSelectExtremas.TrimEnd(';');
strRankingWeights = strRankingWeights.TrimEnd(';');
strRankingExpressions = strRankingExpressions.TrimEnd(';');
strColumnNames = strColumnNames.TrimEnd(';');
SPRanking spRanking = new SPRanking();
spRanking.ShowInternalAttributes = ShowInternalAttributes;
//Quoting is done in GetStoredProc Command
//string strExecSQL = strInput.Replace("'", "''");
strSQLReturn = spRanking.GetStoredProcedureCommand(strInput, strSelectExtremas, strRankingWeights, strRankingExpressions, strColumnNames);
}
}
else
{
//Query does not contain a preference --> return original query
strSQLReturn = strInput;
}
}
catch (Exception e)
{
//Parse syntaxerror
throw new Exception(e.Message);
}
return strSQLReturn;
}
internal string ParsePreferenceSQL(PrefSQLModel prefSQL)
{
return ParsePreferenceSQL(prefSQL.OriginalPreferenceSql, prefSQL);
}
internal DataTable ParseAndExecutePrefSQL(string connectionString, string driverString, PrefSQLModel prefSqlModel)
{
Helper.ConnectionString = connectionString;
Helper.DriverString = driverString;
Helper.Cardinality = Cardinality;
Helper.WindowHandling = WindowHandling;
DataTable dt = Helper.GetResults(ParsePreferenceSQL(prefSqlModel), SkylineType, prefSqlModel, ShowInternalAttributes);
TimeInMilliseconds = Helper.TimeInMilliseconds;
NumberOfComparisons = Helper.NumberOfComparisons;
NumberOfMoves = Helper.NumberOfMoves;
return dt;
}
internal string GetAnsiSqlFromPrefSqlModel(PrefSQLModel prefSqlModel)
{
return ParsePreferenceSQL(prefSqlModel.OriginalPreferenceSql, prefSqlModel);
}
internal DataTable ExecuteFromPrefSqlModel(string dbConnection, string dbProvider, PrefSQLModel prefSqlModel)
{
return ParseAndExecutePrefSQL(dbConnection, dbProvider, prefSqlModel);
}
/// <summary>
/// Returns a datatable with the tuples from the SQL statement
/// The sql will be resolved into pieces, in order to call the Skyline algorithms without MSSQL CLR
/// </summary>
/// <param name="strPrefSQL"></param>
/// <param name="strategy"></param>
/// <param name="model"></param>
/// <returns></returns>
public DataTable GetResults(String strPrefSQL, SkylineStrategy strategy, PrefSQLModel model, bool ShowInternalAttributes)
{
DataTable dt = new DataTable();
//Default Parameter
string strQuery = "";
string strOperators = "";
int numberOfRecords = 0;
string[] parameter = null;
//Native SQL algorithm is already a valid SQL statement
if (strPrefSQL.StartsWith("SELECT", true, null))
{
if (model == null || !model.HasSkylineSample)
{
//If query doesn't need skyline calculation (i.e. query without preference clause) --> set algorithm to nativeSQL
strategy = new SkylineSQL();
}
else
{
throw new Exception("native SQL not yet supported."); // TODO: consider native SQL support
}
}
else
{
//Determine parameter only with skyline of clause and not with weihtedsum clause
DetermineParameters(strPrefSQL, out parameter, out strQuery, out strOperators, out numberOfRecords);
}
try
{
if (model != null && model.Ranking.Count > 0)
{
SPRanking ranking = new SPRanking();
ranking.Provider = DriverString;
ranking.ConnectionString = ConnectionString;
string strSelectExtremas = "";
string strRankingWeights = "";
string strRankingExpressions = "";
string strColumnNames = "";
// Set the decimal seperator, because prefSQL double values are always with decimal separator "."
NumberFormatInfo format = new NumberFormatInfo();
format.NumberDecimalSeparator = ".";
foreach (RankingModel rankingModel in model.Ranking)
{
strSelectExtremas += rankingModel.SelectExtrema + ";";
strRankingWeights += rankingModel.Weight.ToString(format) + ";";
strRankingExpressions += rankingModel.Expression + ";";
strColumnNames += rankingModel.FullColumnName.Replace(".", "_") + ";";
}
strSelectExtremas = strSelectExtremas.TrimEnd(';');
strRankingWeights = strRankingWeights.TrimEnd(';');
strRankingExpressions = strRankingExpressions.TrimEnd(';');
dt = ranking.GetRankingTable(strQuery, strSelectExtremas, strRankingWeights, strRankingExpressions, ShowInternalAttributes, strColumnNames);
}
else if (strategy.IsNative())
{
if (model == null || !model.HasSkylineSample)
{
//Native SQL
//Generic database provider
//Create the provider factory from the namespace provider, you could create any other provider factory.. for Oracle, MySql, etc...
DbProviderFactory factory = DbProviderFactories.GetFactory(DriverString);
// use the factory object to create Data access objects.
DbConnection connection = factory.CreateConnection(); // will return the connection object, in this case, SqlConnection ...
if (connection != null)
{
connection.ConnectionString = ConnectionString;
connection.Open();
DbCommand command = connection.CreateCommand();
command.CommandText = strPrefSQL;
DbDataAdapter db = factory.CreateDataAdapter();
if (db != null)
{
db.SelectCommand = command;
db.Fill(dt);
}
}
}
else
{
throw new Exception("native SQL not yet supported."); // TODO: consider native SQL support
}
}
else
{
if (strategy.SupportImplicitPreference() == false && model.ContainsOpenPreference)
{
throw new Exception(strategy.GetType() + " does not support implicit preferences!");
}
if (strategy.SupportIncomparable() == false && model.WithIncomparable)
{
throw new Exception(strategy.GetType() + " does not support incomparale tuples");
}
//Set the database provider
strategy.Provider = DriverString;
strategy.ConnectionString = ConnectionString;
strategy.Cardinality = Cardinality;
strategy.WindowHandling = WindowHandling;
strategy.RecordAmountLimit = numberOfRecords;
strategy.HasIncomparablePreferences = model.WithIncomparable;
strategy.AdditionParameters = parameter;
strategy.SortType = (int)model.Ordering;
if (!model.HasSkylineSample)
{
dt = strategy.GetSkylineTable(strQuery, strOperators);
TimeInMilliseconds = strategy.TimeMilliseconds;
NumberOfComparisons = strategy.NumberOfComparisons;
NumberOfMoves = strategy.NumberOfMoves;
}
else
{
var skylineSample = new SkylineSampling
{
SubsetCount = model.SkylineSampleCount,
SubsetDimension = model.SkylineSampleDimension,
SelectedStrategy = strategy
};
dt = skylineSample.GetSkylineTable(strQuery, strOperators);
TimeInMilliseconds = skylineSample.TimeMilliseconds;
//NumberOfOperations = skylineSample.NumberOfOperations;
}
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
throw;
}
return dt;
}
/// <summary>TODO</summary>
/// <param name="model">model of parsed Preference SQL Statement</param>
/// <param>Preference SQL Statement WITHOUT PREFERENCES</param>
/// <param name="strOperators">Returns the operators</param>
/// <returns>TODO</returns>
private string BuildPreferencesBNL(PrefSQLModel model, out string strOperators)
{
string strSQL = "";
strOperators = "";
//Build Skyline only if more than one attribute
if (model.Skyline.Count > 0)
{
//Build the where clause with each column in the skyline
for (int iChild = 0; iChild < model.Skyline.Count; iChild++)
{
strSQL += ", " + model.Skyline[iChild].RankExpression + " AS SkylineAttribute" + iChild;
strOperators += "LOW;";
//Incomparable field --> Add string field
if (model.Skyline[iChild].Comparable == false)
{
strSQL += ", " + model.Skyline[iChild].IncomparableAttribute;
strOperators += "INCOMPARABLE" + ";";
}
}
}
strOperators = strOperators.TrimEnd(';');
strSQL = strSQL.TrimStart(',');
return strSQL;
}