Beispiel #1
0
        public virtual SqlColumnAlias TraverseSimplePropertySpan(string propertyPath, ref IPropertyMap propertyMap)
        {
            SqlColumnAlias result       = null;
            IPropertyMap   parentMap    = null;
            ArrayList      propertyMaps = GetPathPropertyMaps(propertyPath);
            string         path         = "";
            JoinType       joinType;

            foreach (IPropertyMap pathMap in propertyMaps)
            {
                propertyMap = pathMap;
                if (propertyMaps.IndexOf(propertyMap) < propertyMaps.Count - 1)
                {
                    if (path.Length > 0)
                    {
                        path += ".";
                    }
                    path += propertyMap.Name;

                    if (HasNullableColumn(propertyMap))
                    {
                        joinType = JoinType.OuterJoin;
                    }
                    else
                    {
                        joinType = JoinType.InnerJoin;
                    }

                    joinTree.SetupJoin(propertyMap, parentMap, path, joinType);
                }
                else
                {
                    if (path == "")
                    {
                        result = GetPropertyColumn(propertyMap, propertyMap);
                    }
                    else
                    {
                        result = GetPropertyColumn(propertyMap, path);
                    }
                }
                parentMap = propertyMap;
            }

            return(result);
        }
Beispiel #2
0
        public virtual void GetListPropertySubselectAndAlias(IPropertyMap propertyMap, object hash, Hashtable columns, ArrayList order, string propPath, string suggestion)
        {
            if (hash == null)
            {
                hash = propertyMap;
            }
            ITableMap     listTableMap   = propertyMap.MustGetTableMap();
            ITableMap     parentTableMap = propertyMap.ClassMap.MustGetTableMap();
            SqlTableAlias parentTable    = sqlEmitter.GetTableAlias(parentTableMap, hash);

            SqlSelectStatement subSelect = new SqlSelectStatement(parentTableMap.SourceMap);

            //Hmmm....can an alias be redefined in a subselect?
            //SqlTableAlias listTable = subSelect.GetSqlTableAlias(listTableMap, "cnt" + subSelect.GetNextTableAliasIndex());
            SqlTableAlias listTable = subSelect.GetSqlTableAlias(listTableMap, "cnt" + sqlEmitter.Select.GetNextTableAliasIndex());

            SqlCountFunction count = new SqlCountFunction();

            subSelect.SqlSelectClause.AddSqlAliasSelectListItem(count);

            subSelect.SqlFromClause.AddSqlAliasTableSource(listTable);

            foreach (IColumnMap fkIdColumnMap in propertyMap.GetAllIdColumnMaps())
            {
                IColumnMap idColumnMap = fkIdColumnMap.MustGetPrimaryKeyColumnMap();

                SqlColumnAlias     fkIdColumn = listTable.GetSqlColumnAlias(fkIdColumnMap);
                SqlColumnAlias     idColumn   = parentTable.GetSqlColumnAlias(idColumnMap);
                SqlSearchCondition search     = subSelect.SqlWhereClause.GetNextSqlSearchCondition();

                search.GetSqlComparePredicate(fkIdColumn, SqlCompareOperatorType.Equals, idColumn);
            }

            if (suggestion == "")
            {
                suggestion = propPath;
            }

            SqlAliasSelectListItem countAlias = this.sqlEmitter.Select.SqlSelectClause.AddSqlAliasSelectListItem(subSelect, suggestion);

            this.sqlEmitter.PropertyColumnMap[propPath] = countAlias.SqlExpressionAlias.Alias;
        }
Beispiel #3
0
        private void JoinNonPrimary(IPropertyMap iPropertyMap)
        {
            foreach (IColumnMap idColumn in iPropertyMap.GetAllIdColumnMaps())
            {
                SqlTableAlias  thisTableAlias = this.sqlEmitter.Select.GetSqlTableAlias(idColumn.TableMap.Name);
                SqlColumnAlias thisColAlias   = thisTableAlias.GetSqlColumnAlias(idColumn.Name);

                SqlTableAlias  parentTableAlias = this.sqlEmitter.Select.GetSqlTableAlias(idColumn.PrimaryKeyTable);
                SqlColumnAlias parentColAlias   = parentTableAlias.GetSqlColumnAlias(idColumn.PrimaryKeyColumn);

                if (!joinedNonPrimaries.ContainsKey(thisColAlias))
                {
                    if (!(joinedNonPrimaries[thisColAlias] == parentColAlias))
                    {
                        SqlSearchCondition search = this.sqlEmitter.Select.SqlWhereClause.GetNextSqlSearchCondition();
                        search.GetSqlComparePredicate(parentColAlias, SqlCompareOperatorType.Equals, thisColAlias);

                        joinedNonPrimaries[thisColAlias] = parentColAlias;
                    }
                }
            }
        }
 public virtual void Visited(SqlColumnAlias columnAlias)
 {
 }
Beispiel #5
0
        public virtual void GetPropertyColumnNamesAndAliases(IPropertyMap propertyMap, object hash, Hashtable columns, ArrayList order, string path, string propPath, string suggestion)
        {
            if (hash == null)
            {
                hash = propertyMap;
            }
            SqlTableAlias tbl           = sqlEmitter.GetTableAlias(propertyMap.MustGetTableMap(), hash);
            IList         columnAliases = new ArrayList();

            if (propertyMap.IsIdentity)
            {
                IClassMap  classMap      = propertyMap.ClassMap;
                IColumnMap typeColumnMap = classMap.GetTypeColumnMap();
                if (typeColumnMap != null)
                {
                    string         pathParent    = GetPathParent(path);
                    string         suggestedPath = pathParent.Length == 0 ? "NPersistTypeColumn" : pathParent + ".NPersistTypeColumn";
                    SqlColumnAlias column        = GetPropertyColumnAlias(tbl, suggestedPath, typeColumnMap, suggestedPath);
                    columnAliases.Add(column);
                }
            }

            if (suggestion == "")
            {
                suggestion = propPath;
            }
            //      bool hasTypeColumn = false;

            IPropertyMap inverse = propertyMap.GetInversePropertyMap();

            //Type column first
            if (inverse != null)
            {
                IColumnMap inverseTypeColumnMap = inverse.ClassMap.GetTypeColumnMap();
                foreach (IColumnMap columnMap in propertyMap.GetAllColumnMaps())
                {
                    if (inverseTypeColumnMap != null && inverseTypeColumnMap == columnMap.GetPrimaryKeyColumnMap())
                    {
                        string suggestionString;
                        suggestionString = propPath.Length == 0 ? "NPersistTypeColum" : propPath + ".NPersistTypeColumn";

                        SqlColumnAlias column = GetPropertyColumnAlias(tbl, path, columnMap, suggestionString);
                        columnAliases.Add(column);
                    }
                }
            }

            foreach (IColumnMap columnMap in propertyMap.GetAllColumnMaps())
            {
                if (inverse != null)
                {
                    IColumnMap inverseTypeColumnMap = inverse.ClassMap.GetTypeColumnMap();
                    if (inverseTypeColumnMap != null && inverseTypeColumnMap == columnMap.GetPrimaryKeyColumnMap())
                    {
                        continue;
                    }
                }

                string suggestionString;

                suggestionString = suggestion;

                SqlColumnAlias column = GetPropertyColumnAlias(tbl, path, columnMap, suggestionString);
                columnAliases.Add(column);
            }

            foreach (SqlColumnAlias column in columnAliases)
            {
                if (!(columns.ContainsKey(column)))
                {
                    columns[column] = column;
                    order.Add(column);

                    //Note: Important stuff, right here in nowhere-ville!!
                    if (this.sqlEmitter.PropertyColumnMap.ContainsKey(propPath))
                    {
                        ArrayList arrAliases;
                        if (this.sqlEmitter.PropertyColumnMap[propPath] is string)
                        {
                            arrAliases = new ArrayList();
                            arrAliases.Add(this.sqlEmitter.PropertyColumnMap[propPath]);
                            this.sqlEmitter.PropertyColumnMap[propPath] = arrAliases;
                        }
                        else
                        {
                            arrAliases = (ArrayList)this.sqlEmitter.PropertyColumnMap[propPath];
                        }
                        arrAliases.Add(column.Alias);
                    }
                    else
                    {
                        this.sqlEmitter.PropertyColumnMap[propPath] = column.Alias;
                    }
                }
            }
        }