public JoinClause(ObjectReference table, JoinType joinType, SimpleExpression joinExpression) { if (table == null) throw new ArgumentNullException("table"); _table = table; _joinType = joinType; _joinExpression = joinExpression; }
public Table(Type memberType, JoinType joinType) { EntityType = memberType; Name = memberType.GetTableName(); JoinType = joinType; Columns = MapRepository.Instance.GetColumns(memberType); }
/// <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 PrettyPolyMeshLayer() : base() { minTileSize = 100; outerJoinType = JoinType.Rounded; innerJoinType = JoinType.Rounded; }
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 JoinedTable(JoinType Type, IQueryTable OuterTable, string InnerKey, string OuterKey) { this.OuterTable = OuterTable; this.InnerKey = InnerKey; this.OuterKey = OuterKey; this.Type = Type; }
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 override void AddJoin(string tableName, string alias, string[] fkColumns, string[] pkColumns, JoinType joinType, SqlString on) { //arbitrary on clause ignored!! AddJoin(tableName, alias, fkColumns, pkColumns, joinType); AddCondition(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); }
/// <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; }
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"); } */ }
public JoinBlock(QueryBlock query, JoinType joinType, TableRef innerRef, StatementBlock on) { this.query = query; JoinType = joinType; InnerRef = innerRef; On = on; }
public JoinedTableExpression(IAliasedExpression left, IAliasedExpression right, JoinType joinType, TableAlias alias) : base(alias) { LeftTable = left; RightTable = right; JoinType = joinType; }
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 JoinedTableExpression(IAliasedExpression left, IAliasedExpression right, JoinType joinType, TableAlias alias, Evaluant.NLinq.Expressions.BinaryExpression on) : base(alias) { LeftTable = left; RightTable = right; JoinType = joinType; On = on; }
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 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; }
internal JoinPart(JoinType joinType, SqlQueryExpression subQuery, SqlExpression onExpression) { if (subQuery == null) throw new ArgumentNullException("subQuery"); OnExpression = onExpression; JoinType = joinType; SubQuery = subQuery; }
internal JoinPart(JoinType joinType, ObjectName tableName, SqlExpression onExpression) { if (tableName == null) throw new ArgumentNullException("tableName"); OnExpression = onExpression; JoinType = joinType; TableName = tableName; }
public Join(ISessionFactoryImplementor factory, IAssociationType associationType, string alias, JoinType joinType, string[] lhsColumns) { this.associationType = associationType; this.joinable = associationType.GetAssociatedJoinable(factory); this.alias = alias; this.joinType = joinType; this.lhsColumns = lhsColumns; }
public override void AddJoin(string tableName, string alias, string[] fkColumns, string[] pkColumns, JoinType joinType) { if (joinType == JoinType.FullJoin) { throw new AssertionFailure("Cache does not support full outer joins"); } base.AddJoin(tableName, alias, fkColumns, pkColumns, joinType); }
public JoinExpression(Expression left, Expression right, JoinType type, Expression filter) : this() { SetArgument("left", left); SetArgument("right", right); SetArgument("type", type); if (filter != null) SetArgument("filter", filter); }
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 Query Join(JoinType joinType, object rightTableSql, string rightTableAlias, params JoinColumnPair[] pairs) { if (_ListJoin == null) _ListJoin = new JoinList(); Join join = new Join(joinType, rightTableSql, rightTableAlias, pairs); _ListJoin.Add(join); return this; }
public IEnumerable<string> GetJoinClauses(ObjectName mainTableName, IEnumerable<ObjectReference> references, JoinType joinType = JoinType.Inner) { _done.AddOrUpdate(mainTableName, string.Empty, (s, o) => string.Empty); var tablePairs = GetTableNames(references, mainTableName.Schema).Distinct().ToList(); foreach (var tablePair in tablePairs) { AddJoin(tablePair.Item1, tablePair.Item2, joinType); } return tablePairs.Select(tp => _done[tp.Item2]).Distinct(); }
public IdentifierNode(string[] parts, JoinType[] joins, Token token, int tokenIndex) : base(token, tokenIndex) { if (joins.Length != parts.Length - 1) { throw new InternalCompilerException("Error constructing IdentifierNode: Part count must be one greater than join count."); } Joins = joins; Parts = parts; }
public WhereClause(JoinType joinType) { JoinType = joinType; }
public Application_PeopleQuery <Application_DeliveryMethodQuery <K, T>, T> JoinApplication_People(JoinType joinType = JoinType.Inner, bool preloadEntities = false) { var joinedQuery = new Application_PeopleQuery <Application_DeliveryMethodQuery <K, T>, T>(Db); return(Join(joinedQuery, string.Concat(joinType.GetJoinString(), " [Application].[People] AS {1} {0} ON", "{2}.[LastEditedBy] = {1}.[PersonID]"), o => ((Application_DeliveryMethod)o)?.Application_People, (e, fv, ppe) => { var child = (Application_People)ppe(QueryHelpers.Fill <Application_People>(null, fv)); if (e != null) { ((Application_DeliveryMethod)e).Application_People = child; } return child; } , typeof(Application_People), preloadEntities)); }
public Purchasing_SupplierQuery <Application_DeliveryMethodQuery <K, T>, T> JoinPurchasing_Suppliers(JoinType joinType = JoinType.Inner, bool attach = false) { var joinedQuery = new Purchasing_SupplierQuery <Application_DeliveryMethodQuery <K, T>, T>(Db); return(JoinSet(() => new Purchasing_SupplierTableQuery <Purchasing_Supplier>(Db), joinedQuery, string.Concat(joinType.GetJoinString(), " [Purchasing].[Suppliers] AS {1} {0} ON", "{2}.[DeliveryMethodID] = {1}.[DeliveryMethodID]"), (p, ids) => ((Purchasing_SupplierWrapper)p).Id.In(ids.Select(id => (System.Int32)id)), (o, v) => ((Application_DeliveryMethod)o).Purchasing_Suppliers.Attach(v.Cast <Purchasing_Supplier>()), p => (long)((Purchasing_Supplier)p).DeliveryMethodID, attach)); }
/// <summary> /// Join /// </summary> /// <param name="sqlable"></param> /// <param name="shortName">表名简写</param> /// <param name="leftFiled">join左边连接字段</param> /// <param name="RightFiled">join右边连接字段</param> /// <param name="type">join类型</param> /// <returns></returns> public static Sqlable Join <T>(this Sqlable sqlable, string shortName, string leftFiled, string RightFiled, JoinType type) { Check.ArgumentNullException(sqlable.Sql, "语法错误,正确用法:sqlable.Form(“table”).Join"); sqlable.Sql.AppendFormat(" {0} JOIN {1} {2} {3} ON {4} = {5} ", type.ToString(), typeof(T).Name.GetTranslationSqlName(), shortName, sqlable.DB.IsNoLock.GetLockString(), leftFiled, RightFiled); return(sqlable); }
public new IQueryProviderWithIncludes <T> Include <T2>(Expression <Func <T, T2> > expression, string tableAlias, JoinType joinType = JoinType.Left) where T2 : class { return((IQueryProviderWithIncludes <T>)base.Include(expression, tableAlias, joinType)); }
public static SelectBuilder Join <TEntity1, TEntity2>(this SelectBuilder builder, JoinType joinType, Expression <Func <TEntity1, TEntity2, bool> > condition) { return(builder.Join(joinType, builder.GetNextTableAlias(), condition)); }
public Sales_OrderLineQuery <Warehouse_PackageTypeQuery <K, T>, T> JoinSales_OrderLines(JoinType joinType = JoinType.Inner, bool attach = false) { var joinedQuery = new Sales_OrderLineQuery <Warehouse_PackageTypeQuery <K, T>, T>(Db); return(JoinSet(() => new Sales_OrderLineTableQuery <Sales_OrderLine>(Db), joinedQuery, string.Concat(joinType.GetJoinString(), " [Sales].[OrderLines] AS {1} {0} ON", "{2}.[PackageTypeID] = {1}.[PackageTypeID]"), (p, ids) => ((Sales_OrderLineWrapper)p).Id.In(ids.Select(id => (System.Int32)id)), (o, v) => ((Warehouse_PackageType)o).Sales_OrderLines.Attach(v.Cast <Sales_OrderLine>()), p => (long)((Sales_OrderLine)p).PackageTypeID, attach)); }
public Warehouse_StockItemQuery <Warehouse_PackageTypeQuery <K, T>, T> JoinPackageTypes(JoinType joinType = JoinType.Inner, bool attach = false) { var joinedQuery = new Warehouse_StockItemQuery <Warehouse_PackageTypeQuery <K, T>, T>(Db); return(JoinSet(() => new Warehouse_StockItemTableQuery <Warehouse_StockItem>(Db), joinedQuery, string.Concat(joinType.GetJoinString(), " [Warehouse].[StockItems] AS {1} {0} ON", "{2}.[PackageTypeID] = {1}.[UnitPackageID]"), (p, ids) => ((Warehouse_StockItemWrapper)p).Id.In(ids.Select(id => (System.Int32)id)), (o, v) => ((Warehouse_PackageType)o).PackageTypes.Attach(v.Cast <Warehouse_StockItem>()), p => (long)((Warehouse_StockItem)p).UnitPackageID, attach)); }
public override void AddJoin(string tableName, string alias, string[] fkColumns, string[] pkColumns, JoinType joinType, string on) { AddJoin(tableName, alias, fkColumns, pkColumns, joinType); AddCondition(on); }
private IAsyncQueryProviderWithIncludes <T> QueryProviderWithIncludes(Expression expression, string tableAlias, JoinType joinType) { var joinExpressions = _buildComplexSql.GetJoinExpressions(expression, tableAlias, joinType); foreach (var joinExpression in joinExpressions) { _joinSqlExpressions[joinExpression.Key] = joinExpression.Value; } return(this); }
void SetImpliedJoinType(int joinType) { _impliedJoinType = JoinProcessor.ToHibernateJoinType(joinType); }
public IAsyncQueryProviderWithIncludes <T> Include <T2>(Expression <Func <T, T2> > expression, JoinType joinType = JoinType.Left) where T2 : class { return(QueryProviderWithIncludes(expression, null, joinType)); }
/// <summary> /// 联表查询 /// </summary> /// <typeparam name="T">第一个表的对象</typeparam> /// <typeparam name="T2">联接的表对象</typeparam> /// <param name="queryable"></param> /// <param name="expression">表达示</param> /// <param name="type"></param> /// <returns></returns> public static Queryable <T> JoinTable <T, T2, T3>(this Queryable <T> queryable, Expression <Func <T, T2, T3, object> > expression, JoinType type = JoinType.LEFT) { ResolveExpress re = new ResolveExpress(); queryable.WhereIndex = queryable.WhereIndex + 100; re.Type = ResolveExpressType.nT; var exLeftStr = Regex.Match(expression.ToString(), @"\((.+?)\).+").Groups[1].Value; var exLeftArray = exLeftStr.Split(','); var shortName1 = exLeftArray[1]; var shortName2 = exLeftArray[2]; re.ResolveExpression(re, expression); string joinTableName = type.ToString(); string joinStr = string.Format(" {0} JOIN {1} {2} ON {3} ", /*0*/ queryable.JoinTable.Count == 0 ? (" " + shortName1 + " " + joinTableName) : joinTableName.ToString(), /*1*/ typeof(T3).Name, /*2*/ shortName2, /*3*/ re.SqlWhere.Trim().TrimStart('A').TrimStart('N').TrimStart('D') ); queryable.JoinTable.Add(joinStr); queryable.Params.AddRange(re.Paras); return(queryable); }
public new IQueryProvider <T> IncludeMany(Expression <Func <T, IList> > expression, JoinType joinType = JoinType.Left) { return((IQueryProvider <T>)base.IncludeMany(expression, joinType)); }
/// <summary> /// Returns true if any components of this query are of a different join type than the test /// </summary> public bool IsCompoundFor(JoinType joinType) { return(Count > 1 && (JoinType != joinType || CriteriaList.Any(item => item is WhereClause && ((WhereClause)item).JoinType != JoinType))); }
public IAsyncQueryProvider <T> IncludeMany(Expression <Func <T, IList> > expression, JoinType joinType = JoinType.Left) { _listExpression = expression; return(QueryProviderWithIncludes(expression, null, joinType)); }
void CreateFromJoinElement( IASTNode path, IASTNode alias, int joinType, IASTNode fetchNode, IASTNode propertyFetch, IASTNode with) { bool fetch = fetchNode != null; if (fetch && IsSubQuery) { throw new QueryException("fetch not allowed in subquery from-elements"); } // The path AST should be a DotNode, and it should have been evaluated already. if (path.Type != DOT) { throw new SemanticException("Path expected for join!"); } DotNode dot = ( DotNode )path; //JoinType hibernateJoinType = JoinProcessor.ToHibernateJoinType( joinType ); JoinType hibernateJoinType = _impliedJoinType; dot.JoinType = hibernateJoinType; // Tell the dot node about the join type. dot.Fetch = fetch; // Generate an explicit join for the root dot node. The implied joins will be collected and passed up // to the root dot node. dot.Resolve(true, false, alias == null ? null : alias.Text); FromElement fromElement; if (dot.DataType != null && dot.DataType.IsComponentType) { var factory = new FromElementFactory(CurrentFromClause, dot.GetLhs().FromElement, dot.PropertyPath, alias == null ? null : alias.Text, null, false); fromElement = factory.CreateComponentJoin((ComponentType)dot.DataType); } else { fromElement = dot.GetImpliedJoin(); if (fromElement == null) { throw new InvalidPathException("Invalid join: " + dot.Path); } fromElement.SetAllPropertyFetch(propertyFetch != null); if (with != null) { if (fetch) { throw new SemanticException("with-clause not allowed on fetched associations; use filters"); } HandleWithFragment(fromElement, with); } } if (log.IsDebugEnabled()) { log.Debug("createFromJoinElement() : {0}", _printer.ShowAsString(fromElement, "-- join tree --")); } }
/// <summary> /// Joins the passed in DataTables on the colToJoinOn. /// <para>Returns an appropriate DataTable with zero rows if the colToJoinOn does not exist in both tables.</para> /// </summary> /// <param name="dtblLeft"></param> /// <param name="dtblRight"></param> /// <param name="colToJoinOn"></param> /// <param name="joinType"></param> /// <returns></returns> /// <remarks> /// <para>http://stackoverflow.com/questions/2379747/create-combined-datatable-from-two-datatables-joined-with-linq-c-sharp?rq=1</para> /// <para>http://msdn.microsoft.com/en-us/library/vstudio/bb397895.aspx</para> /// <para>http://www.codinghorror.com/blog/2007/10/a-visual-explanation-of-sql-joins.html</para> /// <para>http://stackoverflow.com/questions/406294/left-join-and-left-outer-join-in-sql-server</para> /// </remarks> public static DataTable JoinTwoDataTablesOnOneColumn(DataTable dtblLeft, DataTable dtblRight, string colToJoinOn, JoinType joinType) { //Change column name to a temp name so the LINQ for getting row data will work properly. string strTempColName = colToJoinOn + "_2"; if (dtblRight.Columns.Contains(colToJoinOn)) { dtblRight.Columns[colToJoinOn].ColumnName = strTempColName; } //Get columns from dtblA DataTable dtblResult = dtblLeft.Clone(); //Get columns from dtblB var dt2Columns = dtblRight.Columns.OfType <DataColumn>().Select(dc => new DataColumn(dc.ColumnName, dc.DataType, dc.Expression, dc.ColumnMapping)); //Get columns from dtblB that are not in dtblA var dt2FinalColumns = from dc in dt2Columns.AsEnumerable() where !dtblResult.Columns.Contains(dc.ColumnName) select dc; //Add the rest of the columns to dtblResult dtblResult.Columns.AddRange(dt2FinalColumns.ToArray()); //No reason to continue if the colToJoinOn does not exist in both DataTables. if (!dtblLeft.Columns.Contains(colToJoinOn) || (!dtblRight.Columns.Contains(colToJoinOn) && !dtblRight.Columns.Contains(strTempColName))) { if (!dtblResult.Columns.Contains(colToJoinOn)) { dtblResult.Columns.Add(colToJoinOn); } return(dtblResult); } switch (joinType) { default: case JoinType.Inner: #region Inner //get row data //To use the DataTable.AsEnumerable() extension method you need to add a reference to the System.Data.DataSetExtension assembly in your project. var rowDataLeftInner = from rowLeft in dtblLeft.AsEnumerable() join rowRight in dtblRight.AsEnumerable() on rowLeft[colToJoinOn] equals rowRight[strTempColName] select rowLeft.ItemArray.Concat(rowRight.ItemArray).ToArray(); //Add row data to dtblResult foreach (object[] values in rowDataLeftInner) { dtblResult.Rows.Add(values); } #endregion break; case JoinType.Left: #region Left var rowDataLeftOuter = from rowLeft in dtblLeft.AsEnumerable() join rowRight in dtblRight.AsEnumerable() on rowLeft[colToJoinOn] equals rowRight[strTempColName] into gj from subRight in gj.DefaultIfEmpty() select rowLeft.ItemArray.Concat((subRight == null)?(dtblRight.NewRow().ItemArray) : subRight.ItemArray).ToArray(); //Add row data to dtblResult foreach (object[] values in rowDataLeftOuter) { dtblResult.Rows.Add(values); } #endregion break; } //Change column name back to original dtblRight.Columns[strTempColName].ColumnName = colToJoinOn; //Remove extra column from result dtblResult.Columns.Remove(strTempColName); return(dtblResult); }
public NetSqlQueryable(IDbSet dbSet, QueryBody queryBody, Expression <Func <TEntity, TEntity2, TEntity3, TEntity4, TEntity5, TEntity6, bool> > onExpression, JoinType joinType = JoinType.Left, string tableName = null, bool noLock = true) : base(dbSet, queryBody) { Check.NotNull(onExpression, nameof(onExpression), "请输入连接条件"); var t6 = new QueryJoinDescriptor { Type = joinType, Alias = "T6", EntityDescriptor = EntityDescriptorCollection.Get <TEntity6>(), On = onExpression, NoLock = noLock }; t6.TableName = tableName.NotNull() ? tableName : t6.EntityDescriptor.TableName; QueryBody.JoinDescriptors.Add(t6); QueryBody.WhereDelegateType = typeof(Func <, , , , , ,>).MakeGenericType(typeof(TEntity), typeof(TEntity2), typeof(TEntity3), typeof(TEntity4), typeof(TEntity5), typeof(TEntity6), typeof(bool)); }
public static SelectBuilder Join <TEntity1, TEntity2, TJoin>(this SelectBuilder builder, JoinType joinType, string alias, Expression <Func <TEntity1, TEntity2, TJoin, bool> > condition) { return(builder.Join(joinType, alias, typeof(TJoin), new[] { typeof(TEntity1), typeof(TEntity2) }, condition)); }
public Join(JoinType joinType, Table table, SourceExpression leftColumn, SourceExpression rightColumn) { this.JoinType = joinType; this.Table = table; this.Conditions.Add(new Condition(leftColumn, SqlOperator.Equals, rightColumn)); }
public override void AddJoin(string tableName, string alias, string[] fkColumns, string[] pkColumns, JoinType joinType) { AddCrossJoin(tableName, alias); for (int j = 0; j < fkColumns.Length; j++) { //full joins are not supported.. yet! if (joinType == JoinType.FullJoin) { throw new InvalidOperationException("full joins are not supported yet"); } afterWhere.Add(" and " + fkColumns[j]); if (joinType == JoinType.LeftOuterJoin) { afterWhere.Add("*"); } afterWhere.Add("="); if (joinType == JoinType.RightOuterJoin) { afterWhere.Add("*"); } afterWhere.Add(alias + StringHelper.Dot + pkColumns[j]); } }
public Join(JoinType joinType, StatementPart right, ConditionExpression condition) { this.JoinType = joinType; this.Table = right; this.Conditions.Add(condition); }
internal void AddJoin(JoinSide left, JoinSide right, JoinType type) { Join = new JoinDefinition(left, right, type); }