Deveel.Data.Sql.Query.QueryExpressionFrom Class Reference

Classes
class	FromExpressionPreparer

Public Member Functions
	QueryExpressionFrom ()
	QueryExpressionFrom (bool ignoreCase)
bool	CompareStrings (string str1, string str2)
void	AddTable (IFromTableSource tableSource)
void	AddExpression (ExpressionReference expressionReference)
void	ExposeColumn (ObjectName columName)
void	ExposeColumns (IFromTableSource tableSource)
void	ExposeColumns (ObjectName tableName)
void	ExposeAllColumns ()
IFromTableSource	GetTableSource (int offset)
IFromTableSource	FindTable (string schema, string name)
ObjectName[]	GetResolvedColumns ()
SqlExpression	FindExpression (ObjectName alias)
ObjectName	ResolveReference (ObjectName refName)

Static Public Member Functions
static QueryExpressionFrom	Create (IRequest context, SqlQueryExpression expression)

Properties
bool	IgnoreCase [get, private set]
QueryExpressionFrom	Parent [get, set]
IExpressionPreparer	ExpressionPreparer [get, private set]
int	SourceCount [get]

Private Member Functions
ObjectName	ResolveColumnReference (ObjectName columnName)
ObjectName	ResolveAliasReference (ObjectName alias)
QueryReference	GlobalResolveReference (int level, ObjectName name)
object	QualifyReference (ObjectName name)

Private Attributes
readonly List< IFromTableSource >	tableSources
readonly List< ExpressionReference >	expressionReferences
readonly List< ObjectName >	exposedColumns

Detailed Description

Definition at line 27 of file QueryExpressionFrom.cs.

Constructor & Destructor Documentation

Deveel.Data.Sql.Query.QueryExpressionFrom.QueryExpressionFrom ( )

inline

Definition at line 32 of file QueryExpressionFrom.cs.

            : this(true) {
        }

Deveel.Data.Sql.Query.QueryExpressionFrom.QueryExpressionFrom ( bool  ignoreCase )

inline

Definition at line 36 of file QueryExpressionFrom.cs.

                                                    {
            IgnoreCase = ignoreCase;

            tableSources = new List<IFromTableSource>();
            expressionReferences = new List<ExpressionReference>();
            exposedColumns = new List<ObjectName>();

            ExpressionPreparer = new FromExpressionPreparer(this);
        }

Member Function Documentation

void Deveel.Data.Sql.Query.QueryExpressionFrom.AddExpression ( ExpressionReference  expressionReference )

inline

Definition at line 65 of file QueryExpressionFrom.cs.

                                                                           {
            expressionReferences.Add(expressionReference);
        }

void Deveel.Data.Sql.Query.QueryExpressionFrom.AddTable ( IFromTableSource  tableSource )

inline

Definition at line 61 of file QueryExpressionFrom.cs.

                                                           {
            tableSources.Add(tableSource);
        }

bool Deveel.Data.Sql.Query.QueryExpressionFrom.CompareStrings ( string  str1, string  str2  )

inline

Definition at line 56 of file QueryExpressionFrom.cs.

                                                             {
            var compareType = IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
            return String.Equals(str1, str2, compareType);
        }

static QueryExpressionFrom Deveel.Data.Sql.Query.QueryExpressionFrom.Create ( IRequest  context, SqlQueryExpression  expression  )

inlinestatic

Definition at line 227 of file QueryExpressionFrom.cs.

                                                                                                  {
            // Get the 'from_clause' from the table expression
            var fromClause = expression.FromClause;
            var ignoreCase = context.Query.IgnoreIdentifiersCase();

            var queryFrom = new QueryExpressionFrom(ignoreCase);
            foreach (var fromTable in fromClause.AllTables) {
                var uniqueKey = fromTable.UniqueKey;
                var alias = fromTable.Alias;

                if (fromTable.IsSubQuery) {
                    // eg. FROM ( SELECT id FROM Part )
                    var subQuery = fromTable.SubQuery;
                    var subQueryFrom = Create(context, subQuery);

                    // The aliased name of the table
                    ObjectName aliasTableName = null;
                    if (alias != null)
                        aliasTableName = new ObjectName(alias);

                    // Add to list of sub-query tables to add to command,
                    queryFrom.AddTable(new FromTableSubQuerySource(ignoreCase, uniqueKey, subQuery, subQueryFrom, aliasTableName));
                } else {
                    // Else must be a standard command table,
                    string name = fromTable.Name;

                    // Resolve to full table name
                    var tableName = context.Query.ResolveTableName(name);

                    if (!context.Query.TableExists(tableName))
                        throw new InvalidOperationException(String.Format("Table '{0}' was not found.", tableName));

                    ObjectName givenName = null;
                    if (alias != null)
                        givenName = new ObjectName(alias);

                    // Get the ITableQueryInfo object for this table name (aliased).
                    ITableQueryInfo tableQueryInfo = context.Query.GetTableQueryInfo(tableName, givenName);

                    queryFrom.AddTable(new FromTableDirectSource(ignoreCase, tableQueryInfo, uniqueKey, givenName, tableName));
                }
            }

            // Set up functions, aliases and exposed variables for this from set,

            foreach (var selectColumn in expression.SelectColumns) {
                // Is this a glob?  (eg. Part.* )
                if (selectColumn.IsGlob) {
                    // Find the columns globbed and add to the 'selectedColumns' result.
                    if (selectColumn.IsAll) {
                        queryFrom.ExposeAllColumns();
                    } else {
                        // Otherwise the glob must be of the form '[table name].*'
                        queryFrom.ExposeColumns(selectColumn.TableName);
                    }
                } else {
                    // Otherwise must be a standard column reference.  Note that at this
                    // time we aren't sure if a column expression is correlated and is
                    // referencing an outer source.  This means we can't verify if the
                    // column expression is valid or not at this point.

                    // If this column is aliased, add it as a function reference to the
                    // select expression

                    string alias = selectColumn.Alias;
                    var v = selectColumn.Expression.AsReferenceName();
                    bool aliasMatchV = (v != null && alias != null &&
                                        queryFrom.CompareStrings(v.Name, alias));
                    if (alias != null && !aliasMatchV) {
                        queryFrom.AddExpression(new ExpressionReference(selectColumn.Expression, alias));
                        queryFrom.ExposeColumn(new ObjectName(alias));
                    } else if (v != null) {
                        var resolved = queryFrom.ResolveReference(v);
                        queryFrom.ExposeColumn(resolved ?? v);
                    } else {
                        string funName = selectColumn.Expression.ToString();
                        queryFrom.AddExpression(new ExpressionReference(selectColumn.Expression, funName));
                        queryFrom.ExposeColumn(new ObjectName(funName));
                    }
                }
            }

            return queryFrom;
        }

void Deveel.Data.Sql.Query.QueryExpressionFrom.ExposeAllColumns ( )

inline

Definition at line 88 of file QueryExpressionFrom.cs.

                                       {
            foreach (var source in tableSources) {
                ExposeColumns(source);
            }
        }

void Deveel.Data.Sql.Query.QueryExpressionFrom.ExposeColumn ( ObjectName  columName )

inline

Definition at line 69 of file QueryExpressionFrom.cs.

                                                       {
            exposedColumns.Add(columName);
        }

void Deveel.Data.Sql.Query.QueryExpressionFrom.ExposeColumns ( IFromTableSource  tableSource )

inline

Definition at line 73 of file QueryExpressionFrom.cs.

                                                                {
            foreach (var column in tableSource.ColumnNames) {
                exposedColumns.Add(column);
            }
        }

void Deveel.Data.Sql.Query.QueryExpressionFrom.ExposeColumns ( ObjectName  tableName )

inline

Definition at line 79 of file QueryExpressionFrom.cs.

                                                        {
            var schema = tableName.Parent != null ? tableName.Parent.Name : null;
            IFromTableSource table = FindTable(schema, tableName.Name);
            if (table == null)
                throw new InvalidOperationException("Table name found: " + tableName);

            ExposeColumns(table);
        }

SqlExpression Deveel.Data.Sql.Query.QueryExpressionFrom.FindExpression ( ObjectName  alias )

inline

Definition at line 108 of file QueryExpressionFrom.cs.

                                                              {
            if (alias == null) 
                throw new ArgumentNullException("alias");

            if (alias.Parent != null)
                return null;

            var aliasName = alias.Name;

            int matchCount = 0;
            SqlExpression expToRetun = null;
            foreach (var reference in expressionReferences) {
                if (matchCount > 1)
                    throw new AmbiguousMatchException(String.Format("Alias '{0}' resolves to multiple expressions in the plan", alias));

                if (CompareStrings(reference.Alias, aliasName)) {
                    expToRetun = reference.Expression;
                    matchCount++;
                }
            }

            return expToRetun;
        }

IFromTableSource Deveel.Data.Sql.Query.QueryExpressionFrom.FindTable ( string  schema, string  name  )

inline

Definition at line 98 of file QueryExpressionFrom.cs.

                                                                      {
            return tableSources.FirstOrDefault(x => x.MatchesReference(null, schema, name));
        }

ObjectName [] Deveel.Data.Sql.Query.QueryExpressionFrom.GetResolvedColumns ( )

inline

Definition at line 102 of file QueryExpressionFrom.cs.

                                                 {
            var columnNames = new ObjectName[exposedColumns.Count];
            exposedColumns.CopyTo(columnNames, 0);
            return columnNames;
        }

IFromTableSource Deveel.Data.Sql.Query.QueryExpressionFrom.GetTableSource ( int  offset )

inline

Definition at line 94 of file QueryExpressionFrom.cs.

                                                           {
            return tableSources[offset];
        }

QueryReference Deveel.Data.Sql.Query.QueryExpressionFrom.GlobalResolveReference ( int  level, ObjectName  name  )

inlineprivate

Definition at line 199 of file QueryExpressionFrom.cs.

                                                                                  {
            ObjectName resolvedName = ResolveReference(name);
            if (resolvedName == null && Parent != null)
                // If we need to descend to the parent, increment the level.
                return Parent.GlobalResolveReference(level + 1, name);

            if (resolvedName != null)
                return new QueryReference(resolvedName, level);

            return null;
        }

object Deveel.Data.Sql.Query.QueryExpressionFrom.QualifyReference ( ObjectName  name )

inlineprivate

Definition at line 211 of file QueryExpressionFrom.cs.

                                                         {
            var referenceName = ResolveReference(name);
            if (referenceName == null) {
                if (Parent == null)
                    throw new InvalidOperationException(String.Format("Reference {0} was not found in context.", name));

                var queryRef = GlobalResolveReference(1, name);
                if (queryRef == null)
                    throw new InvalidOperationException(String.Format("Reference {0} was not found in context.", name));

                return queryRef;
            }

            return referenceName;
        }

ObjectName Deveel.Data.Sql.Query.QueryExpressionFrom.ResolveAliasReference ( ObjectName  alias )

inlineprivate

Definition at line 158 of file QueryExpressionFrom.cs.

                                                                   {
            if (alias.Parent != null)
                return null;

            var aliasName = alias.Name;

            int matchCount = 0;
            ObjectName matched = null;
            foreach (var reference in expressionReferences) {
                if (matchCount > 1)
                    throw new AmbiguousMatchException();

                if (CompareStrings(aliasName, reference.Alias)) {
                    matched = new ObjectName(reference.Alias);
                    matchCount++;
                }
            }

            return matched;
        }

ObjectName Deveel.Data.Sql.Query.QueryExpressionFrom.ResolveColumnReference ( ObjectName  columnName )

inlineprivate

Definition at line 132 of file QueryExpressionFrom.cs.

                                                                         {
            var parent = columnName.Parent;
            var name = columnName.Name;
            string schemaName = null;
            string tableName = null;
            if (parent != null) {
                tableName = parent.Name;
                parent = parent.Parent;
                if (parent != null)
                    schemaName = parent.Name;
            }

            ObjectName matchedColumn = null;

            foreach (var source in tableSources) {
                int matchCount = source.ResolveColumnCount(null, schemaName, tableName, name);
                if (matchCount > 1)
                    throw new AmbiguousMatchException();

                if (matchCount == 1)
                    matchedColumn = source.ResolveColumn(null, schemaName, tableName, name);
            }

            return matchedColumn;
        }

ObjectName Deveel.Data.Sql.Query.QueryExpressionFrom.ResolveReference ( ObjectName  refName )

inline

Definition at line 179 of file QueryExpressionFrom.cs.

                                                               {
            var refList = new List<ObjectName>();

            var resolved = ResolveAliasReference(refName);
            if (resolved != null)
                refList.Add(resolved);

            resolved = ResolveColumnReference(refName);
            if (resolved != null)
                refList.Add(resolved);

            if (refList.Count > 1)
                throw new AmbiguousMatchException();

            if (refList.Count == 0)
                return null;

            return refList[0];
        }

Member Data Documentation

readonly List<ObjectName> Deveel.Data.Sql.Query.QueryExpressionFrom.exposedColumns

private

Definition at line 30 of file QueryExpressionFrom.cs.

readonly List<ExpressionReference> Deveel.Data.Sql.Query.QueryExpressionFrom.expressionReferences

private

Definition at line 29 of file QueryExpressionFrom.cs.

readonly List<IFromTableSource> Deveel.Data.Sql.Query.QueryExpressionFrom.tableSources

private

Definition at line 28 of file QueryExpressionFrom.cs.

Property Documentation

IExpressionPreparer Deveel.Data.Sql.Query.QueryExpressionFrom.ExpressionPreparer

getprivate set

Definition at line 50 of file QueryExpressionFrom.cs.

bool Deveel.Data.Sql.Query.QueryExpressionFrom.IgnoreCase

getprivate set

Definition at line 46 of file QueryExpressionFrom.cs.

QueryExpressionFrom Deveel.Data.Sql.Query.QueryExpressionFrom.Parent

getset

Definition at line 48 of file QueryExpressionFrom.cs.

int Deveel.Data.Sql.Query.QueryExpressionFrom.SourceCount

get

Definition at line 52 of file QueryExpressionFrom.cs.

---

The documentation for this class was generated from the following file:

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Sql.Query/QueryExpressionFrom.cs