A container for the FROM clause of a select statement. More...

Inheritance diagram for Deveel.Data.Sql.Expressions.FromClause:

Public Member Functions
	FromClause ()

void	AddTable (string alias, FromTable table)
	Adds a table as source to the query with a given alias. More...

void	AddTable (string alias, string tableName)
	Adds a simple table reference as the source of the query with a given alias. More...

void	AddTable (string tableName)
	Adds a simple table reference as the source of the query. More...

void	AddSubQuery (SqlQueryExpression subQuery)
	Adds a sub-query expression as source of the query. More...

void	AddSubQuery (string alias, SqlQueryExpression subQuery)
	Adds a sub-query expression as source of the query. More...

void	Join (JoinType joinType, SqlExpression onExpression)
	Sets a join between the last added table and the one that preceeds it. More...

JoinPart	GetJoinPart (int offset)
	Gets the descriptor of the join at the given offset. More...

Properties
IEnumerable< FromTable >	AllTables `[get]`
	Gets an enumeration of all the tables that are the source of the query. More...

int	JoinPartCount `[get]`
	Gets a count of all the joins happening in the clause. More...

bool	IsEmpty `[get]`

Private Member Functions
	FromClause (ObjectData data)

String	CreateNewKey ()

object IPreparable.	Prepare (IExpressionPreparer preparer)
	Converts the underlying value of this instance into an object that can be evaluated by an expression. More...

void ISerializable.	GetData (SerializeData data)

Private Attributes
readonly List< string >	tableNames

readonly List< FromTable >	fromTables

readonly List< JoinPart >	joinParts

int	tableKey
	An id used for making unique names for anonymous inner selects. More...

Detailed Description

A container for the FROM clause of a select statement.

This handles the different types of joins.

Definition at line 32 of file FromClause.cs.

Constructor & Destructor Documentation

Deveel.Data.Sql.Expressions.FromClause.FromClause ( )

inline

Definition at line 33 of file FromClause.cs.

                             {
             fromTables = new List<FromTable>();
             joinParts = new List<JoinPart>();
             tableNames = new List<string>();
         }

Deveel.Data.Sql.Expressions.FromClause.FromClause ( ObjectData data )

inlineprivate

Definition at line 39 of file FromClause.cs.

                                             {
             var tableNames = data.GetValue<string[]>("TableNames");
             var fromTables = data.GetValue<FromTable[]>("FromTables");
             var joinParts = data.GetValue<JoinPart[]>("JoinParts");
 
             this.tableNames = new List<string>();
             this.fromTables = new List<FromTable>();
             this.joinParts = new List<JoinPart>();
 
             if (tableNames != null)
                 this.tableNames.AddRange(tableNames);
             if (fromTables != null)
                 this.fromTables.AddRange(fromTables);
             if (joinParts != null)
                 this.joinParts.AddRange(joinParts);
         }

Member Function Documentation

void Deveel.Data.Sql.Expressions.FromClause.AddSubQuery ( SqlQueryExpression subQuery )

inline

Adds a sub-query expression as source of the query.

Parameters

subQuery The sub-query expression as source of the query.

See also: AddSubQuery(string, SqlQueryExpression)

Definition at line 134 of file FromClause.cs.

                                                              {
             AddSubQuery(null, subQuery);
         }

void Deveel.Data.Sql.Expressions.FromClause.AddSubQuery	(	string	alias,
		SqlQueryExpression	subQuery
	)

inline

Adds a sub-query expression as source of the query.

Parameters

alias	The unique alias name of the expression within the clause.
subQuery	The sub-query expression as source of the query.

See also: AddTable(string, FromTable), SqlQueryExpression

Definition at line 145 of file FromClause.cs.

                                                                            {
             AddTable(alias, new FromTable(subQuery, alias));
         }

void Deveel.Data.Sql.Expressions.FromClause.AddTable	(	string	alias,
		FromTable	table
	)

inline

Adds a table as source to the query with a given alias.

Parameters

alias	The unique name alias of the table source within the clause.
table	The table source object to query from.

Definition at line 93 of file FromClause.cs.

                                                             {
             if (table == null) 
                 throw new ArgumentNullException("table");
 
             if (!String.IsNullOrEmpty(alias)) {
                 if (tableNames.Contains(alias))
                     throw new ArgumentException(String.Format("Duplicated table name {0} is FROM clause.", alias));
 
                 tableNames.Add(alias);
             }
 
             // Create a new unique key for this table
             string key = CreateNewKey();
             table.UniqueKey = key;
             fromTables.Add(table);
         }

void Deveel.Data.Sql.Expressions.FromClause.AddTable	(	string	alias,
		string	tableName
	)

inline

Adds a simple table reference as the source of the query with a given alias.

Parameters

alias	The unique name alias of the table source within the clause.
tableName	The name of the table in the database to query from.

See also: AddTable(string, FromTable)

Definition at line 116 of file FromClause.cs.

                                                              {
             AddTable(alias, new FromTable(tableName, alias));
         }

void Deveel.Data.Sql.Expressions.FromClause.AddTable ( string tableName )

inline

Adds a simple table reference as the source of the query.

Parameters

tableName The name of the table in the database to query from.

See also: AddTable(string, string)

Definition at line 125 of file FromClause.cs.

                                                {
             AddTable(null, tableName);
         }

String Deveel.Data.Sql.Expressions.FromClause.CreateNewKey ( )

inlineprivate

Definition at line 83 of file FromClause.cs.

                                       {
             ++tableKey;
             return tableKey.ToString(CultureInfo.InvariantCulture);
         }

void ISerializable. Deveel.Data.Sql.Expressions.FromClause.GetData ( SerializeData data )

inlineprivate

Implements Deveel.Data.Serialization.ISerializable.

Definition at line 210 of file FromClause.cs.

                                                        {
             if (tableNames != null)
                 data.SetValue("TableNames", tableNames.ToArray());
             if (fromTables != null)
                 data.SetValue("FromTables", fromTables.ToArray());
             if (joinParts != null)
                 data.SetValue("JoinParts", joinParts.ToArray());
         }

JoinPart Deveel.Data.Sql.Expressions.FromClause.GetJoinPart ( int offset )

inline

Gets the descriptor of the join at the given offset.

Parameters

offset The offset of the join descriptor to get.

Returns

Returns an instance of

See also: JoinPart

that describes the type of join at the given offset within the clause.

See also: Join

Definition at line 174 of file FromClause.cs.

                                                 {
             return joinParts[offset];
         }

void Deveel.Data.Sql.Expressions.FromClause.Join	(	JoinType	joinType,
		SqlExpression	onExpression
	)

inline

Sets a join between the last added table and the one that preceeds it.

Parameters

joinType	The type of join to apply to the two tables.
onExpression	The condition for the two tables to join.

Definition at line 154 of file FromClause.cs.

                                                                         {
             var lastTable = fromTables[fromTables.Count - 1];
             if (lastTable.IsSubQuery) {
                 var subQuery = lastTable.SubQuery;
                 joinParts.Add(new JoinPart(joinType, subQuery, onExpression));
             } else {
                 var tableName = ObjectName.Parse(lastTable.Name);
                 joinParts.Add(new JoinPart(joinType, tableName, onExpression));
             }
         }

object IPreparable. Deveel.Data.Sql.Expressions.FromClause.Prepare ( IExpressionPreparer preparer )

inlineprivate

Converts the underlying value of this instance into an object that can be evaluated by an expression.

Parameters

preparer The context used to prepare this object.

Returns: Returns an object that can be evaluated by an expression.

Implements Deveel.Data.Sql.Expressions.IPreparable.

Definition at line 178 of file FromClause.cs.

                                                                  {
             var clause = new FromClause();
 
             // Prepare expressions in the JoiningSet first
             int size = joinParts.Count;
             for (int i = 0; i < size; ++i) {
                 var part = joinParts[i];
                 var exp = part.OnExpression;
                 if (exp != null) {
                     exp = exp.Prepare(preparer);
                     if (part.SubQuery != null) {
                         part = new JoinPart(part.JoinType, part.SubQuery,  exp);
                     } else {
                         part = new JoinPart(part.JoinType, part.TableName, exp);
                     }
                 }
 
                 clause.joinParts.Add(part);
             }
 
             // Prepare the StatementTree sub-queries in the from tables
             for (int i = 0; i < fromTables.Count; i++) {
                 var table = fromTables[i];
                 var preparedTable = (FromTable) ((IPreparable) table).Prepare(preparer);
                 var tableAlias = tableNames[i];
                 clause.tableNames.Insert(i, tableAlias);
                 clause.fromTables.Insert(i, preparedTable);
             }
 
             return clause;
         }

Member Data Documentation

readonly List<FromTable> Deveel.Data.Sql.Expressions.FromClause.fromTables

private

Definition at line 57 of file FromClause.cs.

readonly List<JoinPart> Deveel.Data.Sql.Expressions.FromClause.joinParts

private

Definition at line 58 of file FromClause.cs.

int Deveel.Data.Sql.Expressions.FromClause.tableKey

private

An id used for making unique names for anonymous inner selects.

Definition at line 63 of file FromClause.cs.

readonly List<string> Deveel.Data.Sql.Expressions.FromClause.tableNames

private

Definition at line 56 of file FromClause.cs.

Property Documentation

IEnumerable<FromTable> Deveel.Data.Sql.Expressions.FromClause.AllTables

get

Gets an enumeration of all the tables that are the source of the query.

Definition at line 68 of file FromClause.cs.

bool Deveel.Data.Sql.Expressions.FromClause.IsEmpty

get

Definition at line 79 of file FromClause.cs.

int Deveel.Data.Sql.Expressions.FromClause.JoinPartCount

get

Gets a count of all the joins happening in the clause.

Definition at line 75 of file FromClause.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.Expressions/FromClause.cs

Public Member Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation