} // materializeFromItem()
protected DataSet materializeTable(Table table, List <SelectItem> selectItems,
List <FilterItem> whereItems, int firstRow, int maxRows)
{
if (table == null)
{
throw new ArgumentException("Table cannot be null");
}
if (selectItems == null || selectItems.IsEmpty())
{
// add any column (typically this occurs because of COUNT(*)
// queries)
Column[] columns = table.getColumns();
if (columns.Length == 0)
{
logger.warn("Queried table has no columns: {}", table);
}
else
{
selectItems.Add(new SelectItem(columns[0]));
}
}
Schema schema = table.getSchema();
String schemaName;
if (schema == null)
{
schemaName = null;
}
else
{
schemaName = schema.getName();
}
DataSet dataSet;
if (INFORMATION_SCHEMA_NAME.Equals(schemaName))
{
DataSet informationDataSet = materializeInformationSchemaTable
(table, buildWorkingSelectItems(selectItems, whereItems));
informationDataSet = MetaModelHelper.getFiltered(informationDataSet, whereItems);
informationDataSet = MetaModelHelper.getSelection(selectItems, informationDataSet);
informationDataSet = MetaModelHelper.getPaged(informationDataSet, firstRow, maxRows);
dataSet = informationDataSet;
}
else
{
DataSet tableDataSet = materializeMainSchemaTable(table, selectItems, whereItems, firstRow, maxRows);
// conversion is done at materialization time, since it enables
// the refined types to be used also in eg. where clauses.
dataSet = new ConvertedDataSetInterceptor(_converters).intercept(tableDataSet);
}
return(dataSet);
} // materializeTable()
public void Deserialize_NodeStyle_ImageNull()
{
MetaModel.MetaModel model = MetaModelHelper.Create();
var sut = new MetaModelYamlSerializer();
var textReader = new StreamReader(@"Resources\Settings.Yaml");
sut.Deserialize(model, textReader);
textReader.Close();
Assert.IsNull(model.NodeStyles[0].Image);
Assert.IsNull(model.NodeStyles[1].Image);
}
} // materializeMainSchemaTable()
/**
* Executes a simple one-table query against a table in the main schema of
* the subclasses of this class. This default implementation will delegate
* to {@link #materializeMainSchemaTable(Table, Column[], int, int)}.
*
* @param table
* @param selectItems
* @param firstRow
* @param maxRows
* @return
*/
public virtual DataSet materializeMainSchemaTable(Table table, List <SelectItem> selectItems, int firstRow, int maxRows)
{
Column[] columns = new Column[selectItems.Count];
for (int i = 0; i < columns.Length; i++)
{
columns[i] = selectItems[i].getColumn();
}
DataSet dataSet = materializeMainSchemaTable(table, columns, firstRow, maxRows);
dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
return(dataSet);
} // materializeMainSchemaTable()
} // getMainSchemaName()
public override DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows)
{
DocumentConverter documentConverter = _schemaBuilder.getDocumentConverter(table);
SelectItem[] selectItems = MetaModelHelper.createSelectItems(columns);
DataSetHeader header = new CachingDataSetHeader(selectItems);
DocumentSource documentSource = getDocumentSourceForTable(table.getName());
DataSet dataSet = new DocumentSourceDataSet(header, documentSource, documentConverter);
if (maxRows > 0)
{
dataSet = new MaxRowsDataSet(dataSet, maxRows);
}
return(dataSet);
} // materializeMainSchemaTable()
public void SerializeToString_NodeStyle()
{
var model = MetaModelHelper.Create();
model.IconsList.Add(new ModelIcon("button_ok", "ok", "k"));
var refNode = new MapNode(new MapTree(), "Text");
refNode.Bold = true;
refNode.FontSize = 15;
model.NodeStyles.Add(new NodeStyle("Stylish", refNode, false));
var sut = new MetaModelYamlSerializer();
var textWriter = new StringWriter();
sut.Serialize(model, textWriter);
var result = textWriter.ToString();
Assert.IsTrue(result.Contains(MetaModelYamlSerializer.NodeStyles));
Assert.IsTrue(result.Contains("Stylish"));
}
} // materializeTable()
private List <SelectItem> buildWorkingSelectItems(List <SelectItem> selectItems, List <FilterItem> whereItems)
{
List <SelectItem> primarySelectItems = new List <SelectItem>(selectItems.Count);
foreach (SelectItem selectItem in selectItems)
{
ScalarFunction scalarFunction = selectItem.getScalarFunction();
if (scalarFunction == null || isScalarFunctionMaterialized(scalarFunction))
{
primarySelectItems.Add(selectItem);
}
else
{
SelectItem copySelectItem = selectItem.replaceFunction(null);
primarySelectItems.Add(copySelectItem);
}
}
List <SelectItem> evaluatedSelectItems = MetaModelHelper.getEvaluatedSelectItems(whereItems);
return(CollectionUtils.concat(true, primarySelectItems, evaluatedSelectItems));
} // buildWorkingSelectItems()
public abstract String getMainSchemaName(); // throws MetaModelException;
/**
* Execute a simple one-table query against a table in the main schema of
* the subclasses of this class. This default implementation will delegate
* to {@link #materializeMainSchemaTable(Table, List, int, int)} and apply
* WHERE item filtering afterwards.
*
* @param table
* @param selectItems
* @param whereItems
* @param firstRow
* @param maxRows
* @return
*/
public virtual DataSet materializeMainSchemaTable(Table table, List <SelectItem> selectItems, List <FilterItem> whereItems,
int firstRow, int maxRows)
{
List <SelectItem> workingSelectItems = buildWorkingSelectItems(selectItems, whereItems);
DataSet dataSet;
if (whereItems.IsEmpty())
{
// paging is pushed down to materializeMainSchemaTable
dataSet = materializeMainSchemaTable(table, workingSelectItems, firstRow, maxRows);
dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
}
else
{
// do not push down paging, first we have to apply filtering
dataSet = materializeMainSchemaTable(table, workingSelectItems, 1, -1);
dataSet = MetaModelHelper.getFiltered(dataSet, whereItems);
dataSet = MetaModelHelper.getPaged(dataSet, firstRow, maxRows);
dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
}
return(dataSet);
} // materializeMainSchemaTable()
} // constructor
public SimpleDataSetHeader(Column[] columns) : this(MetaModelHelper.createSelectItems(columns))
{
} // constructor
} // getInformationSchema()
public virtual DataSet materializeInformationSchemaTable(Table table, List <SelectItem> selectItems)
{
String tableName = table.getName();
SelectItem[] columnSelectItems = MetaModelHelper.createSelectItems(table.getColumns());
SimpleDataSetHeader header = new SimpleDataSetHeader(columnSelectItems);
Table[] tables = getDefaultSchema().getTables(false);
List <Row> data = new List <Row>();
if ("tables".Equals(tableName))
{
// "tables" columns: name, type, num_columns, remarks
foreach (Table t in tables)
{
String typeString = null;
if (t.GetType() != null)
{
typeString = t.getType().ToString();
}
data.Add(new DefaultRow(header,
new Object[] { t.getName(), typeString, t.getColumnCount(), t.getRemarks() }));
}
}
else if ("columns".Equals(tableName))
{
// "columns" columns: name, type, native_type, size, nullable,
// indexed, table, remarks
foreach (Table t in tables)
{
foreach (Column c in t.getColumns())
{
String typeString = null;
if (t.GetType() != null)
{
typeString = c.getType().ToString();
}
data.Add(new DefaultRow(header, new Object[] { c.getName(), typeString, c.getNativeType(),
c.getColumnSize(), c.isNullable(), c.isIndexed(), t.getName(), c.getRemarks() }));
}
}
}
else if ("relationships".Equals(tableName))
{
// "relationships" columns: primary_table, primary_column,
// foreign_table, foreign_column
foreach (Relationship r in getDefaultSchema().getRelationships())
{
Column[] primaryColumns = r.getPrimaryColumns();
Column[] foreignColumns = r.getForeignColumns();
Table pTable = r.getPrimaryTable();
Table fTable = r.getForeignTable();
for (int i = 0; i < primaryColumns.Length; i++)
{
Column pColumn = primaryColumns[i];
Column fColumn = foreignColumns[i];
data.Add(new DefaultRow(header,
new Object[] { pTable.getName(), pColumn.getName(), fTable.getName(), fColumn.getName() }));
}
}
}
else
{
throw new ArgumentException("Cannot materialize non information_schema table: " + table);
}
DataSet dataSet;
if (data.IsEmpty())
{
dataSet = new EmptyDataSet(selectItems);
}
else
{
dataSet = new InMemoryDataSet(header, data);
}
// Handle column subset
DataSet selectionDataSet = MetaModelHelper.getSelection(selectItems, dataSet);
dataSet = selectionDataSet;
return(dataSet);
} // materializeInformationSchemaTable()
} // constructor
public DataSet executeQuery(Query query)
{
List <SelectItem> selectItems = query.getSelectClause().getItems();
List <FromItem> fromItems = query.getFromClause().getItems();
List <FilterItem> whereItems = query.getWhereClause().getItems();
List <SelectItem> whereSelectItems = query.getWhereClause().getEvaluatedSelectItems();
List <GroupByItem> groupByItems = query.getGroupByClause().getItems();
List <SelectItem> groupBySelectItems = query.getGroupByClause().getEvaluatedSelectItems();
List <SelectItem> havingSelectItems = query.getHavingClause().getEvaluatedSelectItems();
List <SelectItem> orderBySelectItems = query.getOrderByClause().getEvaluatedSelectItems();
List <FilterItem> havingItems = query.getHavingClause().getItems();
List <OrderByItem> orderByItems = query.getOrderByClause().getItems();
int firstRow = (query.getFirstRow() == null ? 1 : query.getFirstRow());
int maxRows = (query.getMaxRows() == null ? -1 : query.getMaxRows());
if (maxRows == 0)
{
// no rows requested - no reason to do anything
return(new EmptyDataSet(selectItems));
}
// check certain common query types that can often be optimized by
// subclasses
bool singleFromItem = fromItems.Count == 1;
bool noGrouping = groupByItems.IsEmpty() && havingItems.IsEmpty();
if (singleFromItem && noGrouping)
{
FromItem fromItem = query.getFromClause().getItem(0);
Table table = fromItem.getTable();
if (table != null)
{
// check for SELECT COUNT(*) queries
if (selectItems.Count == 1)
{
SelectItem selectItem = query.getSelectClause().getItem(0);
if (SelectItem.isCountAllItem(selectItem))
{
bool functionApproximationAllowed = selectItem.isFunctionApproximationAllowed();
if (isMainSchemaTable(table))
{
logger.debug("Query is a COUNT query with {} where items. Trying executeCountQuery(...)",
whereItems.Count);
NNumber count = executeCountQuery(table, whereItems, functionApproximationAllowed);
if (count == null)
{
logger.debug(
"DataContext did not return any count query results. Proceeding with manual counting.");
}
else
{
List <Row> data = new List <Row>(1);
DataSetHeader header = new SimpleDataSetHeader(new SelectItem[] { selectItem });
data.Add(new DefaultRow(header, new Object[] { count }));
return(new InMemoryDataSet(header, data));
}
}
}
}
bool is_simple_select = isSimpleSelect(query.getSelectClause());
if (is_simple_select)
{
// check for lookup query by primary key
if (whereItems.Count == 1)
{
FilterItem whereItem = whereItems[0];
SelectItem selectItem = whereItem.getSelectItem();
if (!whereItem.isCompoundFilter() && selectItem != null && selectItem.getColumn() != null)
{
Column column = selectItem.getColumn();
if (column.isPrimaryKey() && OperatorType.EQUALS_TO.Equals(whereItem.getOperator()))
{
logger.debug(
"Query is a primary key lookup query. Trying executePrimaryKeyLookupQuery(...)");
if (table != null)
{
if (isMainSchemaTable(table))
{
Object operand = whereItem.getOperand();
Row row = executePrimaryKeyLookupQuery(table, selectItems, column, operand);
if (row == null)
{
logger.debug(
"DataContext did not return any GET query results. Proceeding with manual lookup.");
}
else
{
DataSetHeader header = new SimpleDataSetHeader(selectItems);
return(new InMemoryDataSet(header, row));
}
}
}
}
}
}
// check for simple queries with or without simple criteria
if (orderByItems.IsEmpty())
{
DataSet ds = null;
// no WHERE criteria set
if (whereItems.IsEmpty())
{
ds = materializeTable(table, selectItems, firstRow, maxRows);
return(ds);
}
ds = materializeTable(table, selectItems, whereItems, firstRow, maxRows);
return(ds);
}
}
}
}
// Creates a list for all select items that are needed to execute query
// (some may only be used as part of a filter, but not shown in result)
List <SelectItem> workSelectItems = CollectionUtils.concat(true, selectItems, whereSelectItems,
groupBySelectItems, havingSelectItems, orderBySelectItems);
// Materialize the tables in the from clause
DataSet[] fromDataSets = new DataSet[fromItems.Count];
for (int i = 0; i < fromDataSets.Length; i++)
{
FromItem fromItem = fromItems[i];
fromDataSets[i] = materializeFromItem(fromItem, workSelectItems);
}
// Execute the query using the raw data
DataSet dataSet = null; // MetaModelHelper.getCarthesianProduct(fromDataSets, whereItems);
// we can now exclude the select items imposed by the WHERE clause (and
// should, to make the aggregation process faster)
workSelectItems = CollectionUtils.concat(true, selectItems, groupBySelectItems, havingSelectItems,
orderBySelectItems);
if (groupByItems.Count > 0)
{
dataSet = MetaModelHelper.getGrouped(workSelectItems, dataSet, groupByItems);
}
else
{
dataSet = MetaModelHelper.getAggregated(workSelectItems, dataSet);
}
dataSet = MetaModelHelper.getFiltered(dataSet, havingItems);
if (query.getSelectClause().isDistinct())
{
dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
dataSet = MetaModelHelper.getDistinct(dataSet);
dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems);
}
else
{
dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems);
dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
}
dataSet = MetaModelHelper.getPaged(dataSet, firstRow, maxRows);
return(dataSet);
} // executeQuery()
} // executePrimaryKeyLookupQuery()
protected DataSet materializeFromItem(FromItem fromItem, List <SelectItem> selectItems)
{
DataSet dataSet;
JoinType joinType = fromItem.getJoin();
if (fromItem.getTable() != null)
{
// We need to materialize a single table
Table table = fromItem.getTable();
List <SelectItem> selectItemsToMaterialize = new List <SelectItem>();
foreach (SelectItem selectItem in selectItems)
{
FromItem selectedFromItem = selectItem.getFromItem();
if (selectedFromItem != null)
{
if (selectedFromItem.equals(fromItem))
{
selectItemsToMaterialize.Add(selectItem.replaceFunction(null));
}
}
else
{
// the select item does not specify a specific
// from-item
Column selectedColumn = selectItem.getColumn();
if (selectedColumn != null)
{
// we assume that if the table matches, we will use the
// column
if (selectedColumn.getTable() != null && selectedColumn.getTable().Equals(table))
{
selectItemsToMaterialize.Add(selectItem.replaceFunction(null));
}
}
}
}
if (logger.isDebugEnabled())
{
logger.debug("calling materializeTable(" + table.getName() + "," + selectItemsToMaterialize + ",1,-1");
}
// Dispatching to the concrete subclass of
// QueryPostprocessDataContextStrategy
dataSet = materializeTable(table, selectItemsToMaterialize, 1, -1);
}
else if (joinType != JoinType.None)
{
// We need to (recursively) materialize a joined FromItem
if (fromItem.getLeftSide() == null || fromItem.getRightSide() == null)
{
throw new ArgumentException("Joined FromItem requires both left and right side: " + fromItem);
}
DataSet[] fromItemDataSets = new DataSet[2];
// materialize left side
List <SelectItem> leftOn = NArrays.AsList(fromItem.getLeftOn());
fromItemDataSets[0] = materializeFromItem(fromItem.getLeftSide(),
CollectionUtils.concat(true, selectItems, leftOn));
// materialize right side
List <SelectItem> rightOn = NArrays.AsList(fromItem.getRightOn());
fromItemDataSets[1] = materializeFromItem(fromItem.getRightSide(),
CollectionUtils.concat(true, selectItems, rightOn));
FilterItem[] onConditions = new FilterItem[leftOn.Count];
for (int i = 0; i < onConditions.Length; i++)
{
FilterItem whereItem = new FilterItem(leftOn[i], OperatorType.EQUALS_TO, rightOn[i]);
onConditions[i] = whereItem;
}
switch (joinType)
{
case JoinType.INNER:
dataSet = MetaModelHelper.getCarthesianProduct(fromItemDataSets, onConditions);
break;
case JoinType.LEFT:
dataSet = MetaModelHelper.getLeftJoin(fromItemDataSets[0], fromItemDataSets[1], onConditions);
break;
case JoinType.RIGHT:
dataSet = MetaModelHelper.getRightJoin(fromItemDataSets[0], fromItemDataSets[1], onConditions);
break;
default:
throw new ArgumentException("FromItem type not supported: " + fromItem);
}
}
else if (fromItem.getSubQuery() != null)
{
// We need to (recursively) materialize a subquery
dataSet = executeQuery(fromItem.getSubQuery());
}
else
{
throw new ArgumentException("FromItem type not supported: " + fromItem);
}
if (dataSet == null)
{
throw new ArgumentException("FromItem was not succesfully materialized: " + fromItem);
}
return(dataSet);
} // materializeFromItem()
public void Save()
{
MetaModelHelper.CreateWithTestSettingsFile();
MetaModel.MetaModel model = MindMate.MetaModel.MetaModel.Instance;
model.Save();
}
public static DbDataAdapter GetDataAdapter(string TableName, string Suffix, IDbConnection Conn, IDbTransaction Trans, DataDeletionStatus deletionStatus)
{
if (Conn == null)
{
Conn = GetConnection();
}
string command = string.Empty;
DataTable table = GetInstance().Tables[TableName];
string tableAlias = "__gisatable__";
if (Suffix.Length > 0 && !(deletionStatus == DataDeletionStatus.All))
{
StringBuilder selectQuery = new StringBuilder();
selectQuery.AppendFormat("SELECT {3} FROM {0} INNER JOIN (SELECT {3} FROM {0} {2}) {1} ON ", TableName, tableAlias, Suffix, getAllPrimaryKeys(table, null));
foreach (DataColumn column in table.PrimaryKey)
{
if (column.Ordinal > 0)
{
selectQuery.Append(" AND");
}
selectQuery.AppendFormat(" {0}.{2}={1}.{2}", TableName, tableAlias, column.ColumnName);
}
if (deletionStatus == DataDeletionStatus.Exists)
{
selectQuery.AppendFormat(" WHERE {0}.isDeleted=0", tableAlias);
}
else if (deletionStatus == DataDeletionStatus.Deleted)
{
selectQuery.AppendFormat(" WHERE {0}.isDeleted=1", tableAlias);
}
command = selectQuery.ToString();
}
else if (Suffix.Length == 0 && !(deletionStatus == DataDeletionStatus.All))
{
StringBuilder selectQuery = new StringBuilder();
selectQuery.AppendFormat("SELECT {0} FROM {1}", getAllPrimaryKeys(table, null), TableName);
if (deletionStatus == DataDeletionStatus.Exists)
{
selectQuery.AppendFormat(" WHERE {0}.isDeleted=0", TableName);
}
else if (deletionStatus == DataDeletionStatus.Deleted)
{
selectQuery.AppendFormat(" WHERE {0}.isDeleted=1", TableName);
}
command = selectQuery.ToString();
}
if (workingDBMS == "SQLServer")
{
SqlDataAdapter da = new SqlDataAdapter();
SQLCustomCommandBuilder cb = new SQLCustomCommandBuilder(GetInstance().Tables[TableName], ((SqlConnection)(Conn)), MetaModelHelper.getColumnTypes(TableName, "TransactSQL"), ((SqlTransaction)(Trans)));
if (Suffix.Length > 0 && deletionStatus == DataDeletionStatus.All)
{
da.SelectCommand = ((SqlCommand)(cb.GetSelectWithFilterCommand(Suffix)));
}
else if (Suffix.Length > 0 && !(deletionStatus == DataDeletionStatus.All) && command.Length > 0)
{
da.SelectCommand = new SqlCommand(command);
da.SelectCommand.Connection = ((SqlConnection)(Conn));
da.SelectCommand.CommandType = CommandType.Text;
da.SelectCommand.Transaction = ((SqlTransaction)(Trans));
}
else if (Suffix.Length == 0 && command.Length == 0)
{
da.SelectCommand = ((SqlCommand)(cb.SelectAllCommand));
da.SelectCommand.CommandText += "WHERE isDeleted = 0";
}
else if (Suffix.Length == 0 && command.Length > 0)
{
da.SelectCommand = new SqlCommand(command);
da.SelectCommand.Connection = ((SqlConnection)(Conn));
da.SelectCommand.CommandType = CommandType.Text;
da.SelectCommand.Transaction = ((SqlTransaction)(Trans));
}
da.UpdateCommand = ((SqlCommand)(cb.UpdateCommand));
da.DeleteCommand = ((SqlCommand)(cb.DeleteCommand));
da.InsertCommand = ((SqlCommand)(cb.InsertCommand));
Trace.WriteLineIf(SqlTrace.Enabled, da.SelectCommand.CommandText);
return(da);
}
else if (workingDBMS == "Others")
{
OleDbDataAdapter da = new OleDbDataAdapter();
OleDbCustomCommandBuilder cb = new OleDbCustomCommandBuilder(GetInstance().Tables[TableName], ((OleDbConnection)(Conn)), MetaModelHelper.getColumnTypes(TableName, "oleDB"), ((OleDbTransaction)(Trans)));
if (Suffix.Length > 0 && deletionStatus == DataDeletionStatus.All)
{
da.SelectCommand = ((OleDbCommand)(cb.GetSelectWithFilterCommand(Suffix)));
}
else if (Suffix.Length > 0 && !(deletionStatus == DataDeletionStatus.All) && command.Length > 0)
{
da.SelectCommand = new OleDbCommand(command);
da.SelectCommand.Connection = ((OleDbConnection)(Conn));
da.SelectCommand.CommandType = CommandType.Text;
da.SelectCommand.Transaction = ((OleDbTransaction)(Trans));
}
else if (Suffix.Length == 0 && command.Length == 0)
{
da.SelectCommand = ((OleDbCommand)(cb.SelectAllCommand));
da.SelectCommand.CommandText += "WHERE isDeleted = 0";
}
else if (Suffix.Length == 0 && command.Length > 0)
{
da.SelectCommand = new OleDbCommand(command);
da.SelectCommand.Connection = ((OleDbConnection)(Conn));
da.SelectCommand.CommandType = CommandType.Text;
da.SelectCommand.Transaction = ((OleDbTransaction)(Trans));
}
da.UpdateCommand = ((OleDbCommand)(cb.UpdateCommand));
da.DeleteCommand = ((OleDbCommand)(cb.DeleteCommand));
da.InsertCommand = ((OleDbCommand)(cb.InsertCommand));
Trace.WriteLineIf(SqlTrace.Enabled, da.SelectCommand.CommandText);
return(da);
}
else
{
Debug.Assert(false, "(DataAdapter) SGBD desconhecido");
return(null);
}
}
public void Deserialize_NodeStyleImageNotNull()
{
MetaModel.MetaModel model = MetaModelHelper.CreateWithTestSettingsFile();
Assert.IsTrue(model.NodeStyles.TrueForAll(s => s.Image != null));
}
} // getColumnsOfType()
public Column[] getColumnsOfSuperType(SuperColumnType superColumnType)
{
Column[] columns = getColumns();
return(MetaModelHelper.getColumnsBySuperType(columns, superColumnType));
} // getColumnsOfSuperType()
} // _Action_Impl_ForeignKeys class
#endregion getForeignKeys()
public Column[] getColumnsOfType(ColumnType columnType)
{
Column[] columns = getColumns();
return(MetaModelHelper.getColumnsByType(columns, columnType));
} // getColumnsOfType()
} // constructor
public AbstractDataSet(Column[] columns) : this(MetaModelHelper.createSelectItems(columns))
{
} // constructor
} // parse()
/**
* Finds/creates a SelectItem based on the given expression. Unlike the
* {@link #parse(String, String)} method, this method will not actually add
* the selectitem to the query.
*
* @param expression
* @return
*
* @throws MultipleSelectItemsParsedException
* if an expression yielding multiple select-items (such as "*")
* was passed in the expression
*/
public SelectItem findSelectItem(String expression) // throws MultipleSelectItemsParsedException
{
if ("*".Equals(expression))
{
throw new MultipleSelectItemsParsedException(null);
}
if ("COUNT(*)".Equals(expression, StringComparison.CurrentCultureIgnoreCase))
{
return(SelectItem.getCountAllItem());
}
String unmodifiedExpression = expression;
bool functionApproximation;
FunctionType function;
int startParenthesis = expression.IndexOf('(');
if (startParenthesis > 0 && expression.EndsWith(")"))
{
functionApproximation = (expression.StartsWith(SelectItem.FUNCTION_APPROXIMATION_PREFIX));
String functionName = expression.Substring(
(functionApproximation ? SelectItem.FUNCTION_APPROXIMATION_PREFIX.Length : 0), startParenthesis);
function = FunctionTypeFactory.get(functionName.ToUpper());
if (function != null)
{
expression = expression.Substring(startParenthesis + 1, expression.Length - 1).Trim();
if (function is CountAggregateFunction && "*".Equals(expression))
{
SelectItem select_item = SelectItem.getCountAllItem();
select_item.setFunctionApproximationAllowed(functionApproximation);
return(select_item);
}
}
}
else
{
function = null;
functionApproximation = false;
}
String columnName = null;
FromItem fromItem = null;
// attempt to find from item by cutting up the string in prefix and
// suffix around dot.
{
int splitIndex = expression.LastIndexOf('.');
while (fromItem == null && splitIndex != -1)
{
String prefix = expression.Substring(0, splitIndex);
columnName = expression.Substring(splitIndex + 1);
fromItem = _query.getFromClause().getItemByReference(prefix);
splitIndex = expression.LastIndexOf('.', splitIndex - 1);
}
}
if (fromItem == null)
{
if (_query.getFromClause().getItemCount() == 1)
{
fromItem = _query.getFromClause().getItem(0);
columnName = expression;
}
else
{
fromItem = null;
columnName = null;
}
}
if (fromItem != null)
{
if ("*".Equals(columnName))
{
throw new MultipleSelectItemsParsedException(fromItem);
}
else if (fromItem.getTable() != null)
{
Column column = fromItem.getTable().getColumnByName(columnName);
int offset = -1;
while (function == null && column == null)
{
// check for MAP_VALUE shortcut syntax
offset = columnName.IndexOf('.', offset + 1);
if (offset == -1)
{
break;
}
String part1 = columnName.Substring(0, offset);
column = fromItem.getTable().getColumnByName(part1);
if (column != null)
{
String part2 = columnName.Substring(offset + 1);
return(new SelectItem(new MapValueFunction(), new Object[] { part2 }, column, fromItem));
}
}
if (column != null)
{
SelectItem select_item = new SelectItem(function, column, fromItem);
select_item.setFunctionApproximationAllowed(functionApproximation);
return(select_item);
}
}
else if (fromItem.getSubQuery() != null)
{
Query subQuery = fromItem.getSubQuery();
SelectItem subQuerySelectItem = new SelectItemParser(subQuery, _allowExpressionBasedSelectItems)
.findSelectItem(columnName);
if (subQuerySelectItem == null)
{
return(null);
}
return(new SelectItem(subQuerySelectItem, fromItem));
}
}
// if the expression is alias of some select item defined return that
// select item
SelectItem aliasSelectItem = MetaModelHelper.getSelectItemByAlias(_query, unmodifiedExpression);
if (aliasSelectItem != null)
{
return(aliasSelectItem);
}
if (_allowExpressionBasedSelectItems)
{
SelectItem select_item = new SelectItem(function, expression, null);
select_item.setFunctionApproximationAllowed(functionApproximation);
return(select_item);
}
return(null);
} // findSelectItem()
public List <SelectItem> getEvaluatedSelectItems()
{
List <FilterItem> items = getItems();
return(MetaModelHelper.getEvaluatedSelectItems(items));
}
