public Table(Type memberType, JoinType joinType)
 {
     EntityType = memberType;
     Name = memberType.GetTableName();
     JoinType = joinType;
     Columns = MapRepository.Instance.GetColumns(memberType);
 }

 public JoinBlock(QueryBlock query, JoinType joinType, TableRef innerRef, StatementBlock on)
 {
     this.query = query;
     JoinType = joinType;
     InnerRef = innerRef;
     On = on;
 }

 public void JoinAt(int betweenIndex, JoinType joinType, SqlExpression onExpression)
 {
     var planLeft = tablePlans[betweenIndex];
     var planRight = tablePlans[betweenIndex + 1];
     planLeft.RightJoin(planRight, joinType, onExpression);
     planRight.LeftJoin(planLeft, joinType, onExpression);
 }

 public JoinClause(ObjectReference table, JoinType joinType, SimpleExpression joinExpression)
 {
     if (table == null) throw new ArgumentNullException("table");
     _table = table;
     _joinType = joinType;
     _joinExpression = joinExpression;
 }

		public override void AddJoin(string tableName, string alias, string[] fkColumns, string[] pkColumns, JoinType joinType)
		{
			switch (joinType)
			{
				case JoinType.InnerJoin:
					AddCrossJoin(tableName, alias);
					break;
				case JoinType.LeftOuterJoin:
					afterFrom.Add(StringHelper.CommaSpace).Add("outer ").Add(tableName).Add(" ").Add(alias);
					break;
				case JoinType.RightOuterJoin:
					int i = GetPrevTableInsertPoint(afterFrom.ToSqlString());
					afterFrom.Insert(i, "outer ");
					break;
				case JoinType.FullJoin:
					throw new NotSupportedException("join type not supported by Informix");
				default:
					throw new AssertionFailure("undefined join type");
			}

			for (int j = 0; j < fkColumns.Length; j++)
			{
				HasThetaJoins = true;
				afterWhere.Add(" and " + fkColumns[j]);
				afterWhere.Add("=" + alias + StringHelper.Dot + pkColumns[j]);
			}
		}

 public PrettyPolyMeshLayer()
     : base()
 {
     minTileSize = 100;
     outerJoinType = JoinType.Rounded;
     innerJoinType = JoinType.Rounded;
 }

 public JoinedTable(JoinType Type, IQueryTable OuterTable, string InnerKey, string OuterKey)
 {
     this.OuterTable = OuterTable;
     this.InnerKey = InnerKey;
     this.OuterKey = OuterKey;
     this.Type = Type;
 }

        public Join(string fromTableName, string fromColumnName, string toTableName, string toColumnName, JoinType joinType)
        {
            /*
            //lookem up
            ITable tblFrom = (DatabaseTable)DataService.FindTable(fromTableName);
            if (tblFrom == null)
                tblFrom = DataService.FindTableByClassName(fromTableName);

            DatabaseTable tblTo = (DatabaseTable)DataService.FindTable(toTableName);
            if (tblTo == null)
                tblTo = DataService.FindTableByClassName(toTableName);
            
            DatabaseTableColumn fromCol = null;
            DatabaseTableColumn toCol = null;

            if (tblFrom != null) {
                fromCol = tblFrom.GetColumn(fromColumnName);

            }

            if (tblTo != null) {
                toCol = tblTo.GetColumn(toColumnName);
            }

            if (fromCol != null && toCol != null) {
                FromColumn = fromCol;
                ToColumn = toCol;
                Type = joinType;

            } else {
                throw new InvalidOperationException("Can't find the table/columns you're looking for");
            }
            */
        }

 /// <summary>
 /// Construct a CreateAliasEvent
 /// Construct a CreateAliasEvent
 /// </summary>
 /// <param name="methodSig">The signature of the createAlias method we're going to invoke when the event fires</param>
 /// <param name="associationPath">the association path of the alias we're creating</param>
 /// <param name="alias"> the name of the alias we're creating</param>
 /// <param name="joinType">the join type of the alias we're creating. Can be null</param>
 private CreateAliasEvent(MethodSig methodSig, string associationPath, string alias, JoinType joinType)
 {
     this.methodSig = methodSig;
     this.associationPath = associationPath;
     this.alias = alias;
     this.joinType = joinType;
 }

        /// <summary>
        /// Jet engine does not support full joins.
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="alias"></param>
        /// <param name="fkColumns"></param>
        /// <param name="pkColumns"></param>
        /// <param name="joinType"></param>
        public override void AddJoin(string tableName, string alias, string[] fkColumns, string[] pkColumns, JoinType joinType)
        {
            if (joinType == JoinType.FullJoin)
                throw new NotSupportedException("The FULL JOIN is not supported by Jet database engine.");

            base.AddJoin(tableName, alias, fkColumns, pkColumns, joinType);
        }

 public JoinedTableExpression(IAliasedExpression left, IAliasedExpression right, JoinType joinType, TableAlias alias)
     : base(alias)
 {
     LeftTable = left;
     RightTable = right;
     JoinType = joinType;
 }

		public override void AddJoin(string tableName, string alias, string[] fkColumns, string[] pkColumns, JoinType joinType,
		                             SqlString on)
		{
			string joinString;
			switch (joinType)
			{
				case JoinType.InnerJoin:
					joinString = " inner join ";
					break;
				case JoinType.LeftOuterJoin:
					joinString = " left outer join ";
					break;
				case JoinType.RightOuterJoin:
					joinString = " right outer join ";
					break;
				case JoinType.FullJoin:
					joinString = " full outer join ";
					break;
				default:
					throw new AssertionFailure("undefined join type");
			}

			_fromFragment.Add(joinString + tableName + ' ' + alias + " on ");

			for (int j = 0; j < fkColumns.Length; j++)
			{
				_fromFragment.Add(fkColumns[j] + "=" + alias + StringHelper.Dot + pkColumns[j]);
				if (j < fkColumns.Length - 1)
				{
					_fromFragment.Add(" and ");
				}
			}

			AddCondition(_fromFragment, on);
		}

 public Join(string rightTable, string rightTableAlias, string leftField, string rightField, JoinType type)
 {
     LeftField = leftField;
     RightTable = rightTable;
     RightTableAlias = rightTableAlias;
     RightField = rightField;
     Type = type;
 }

 public JoinExpression(JoinType joinType, Expression left, Expression right, Expression condition)
     : base(DbExpressionType.Join, typeof(void))
 {
     this.joinType = joinType;
     this.left = left;
     this.right = right;
     this.condition = condition;
 }

 public QueryJoin(string modelField, IModel joinedModel, string joinedField, JoinType joinType, QExprGroup joinConditions)
 {
     ModelField = modelField;
     JoinedModel = joinedModel;
     JoinedField = joinedField;
     Type = joinType;
     JoinConditions = joinConditions;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Join"/> class.
 /// </summary>
 /// <param name="from">From.</param>
 /// <param name="to">To.</param>
 /// <param name="joinType">Type of the join.</param>
 public Join(TableSchema.TableColumn from, TableSchema.TableColumn to, JoinType joinType,params string[] joinExpressions)
 {
     FromColumn = from;
     ToColumn = to;
     Type = joinType;
     if (joinExpressions != null && joinExpressions.Length > 0)
         JoinExpressions.AddRange(joinExpressions);
 }

 public WhereClause(JoinType joinType, params IWhere[] criteria)
 {
     if (criteria == null || criteria.Length < 2)
     {
         throw new Exception("A where clause can only be created from two or more components.");
     }
     JoinType = joinType;
     Add(criteria);
 }

 public JoinClause(JoinType join, string toTableName, string toColumnName, Comparison @operator, string fromTableName, string fromColumnName)
 {
     this.JoinType = join;
     this.FromTable = fromTableName;
     this.FromColumn = fromColumnName;
     this.ComparisonOperator = @operator;
     this.ToTable = toTableName;
     this.ToColumn = toColumnName;
 }

 public IEnumerable<string> GetJoinClauses(ObjectName mainTableName, IEnumerable<string> tableList, JoinType joinType = JoinType.Inner)
 {
     var tablePairs = tableList.Select(t => new ObjectName(mainTableName.Schema, t)).ToTuplePairs().ToList();
     foreach (var tablePair in tablePairs)
     {
         AddJoin(tablePair.Item1, tablePair.Item2);
     }
     return tablePairs.Select(tp => _done[tp.Item2]);
 }

 public Query Join(JoinType joinType,
     TableSchema leftTableSchema, string leftColumn, string leftTableAlias,
     object rightTableSql, string rightColumn, string rightTableAlias)
 {
     if (_ListJoin == null) _ListJoin = new JoinList();
     Join join = new Join(joinType, leftTableSchema, leftColumn, leftTableAlias, rightTableSql, rightColumn, rightTableAlias);
     _ListJoin.Add(join);
     return this;
 }