CreateFullName() public static method

public static CreateFullName ( tgDataRequest request ) : string
request Tiraggo.Interfaces.tgDataRequest
return string
Exemplo n.º 1
0
        protected static string GetFromStatement(StandardProviderParameters std, tgDynamicQuerySerializable query)
        {
            IDynamicQuerySerializableInternal iQuery = query as IDynamicQuerySerializableInternal;

            string sql = String.Empty;

            int joinCount = 0;

            if (iQuery.InternalJoinItems != null && iQuery.InternalJoinItems.Count > 0)
            {
                joinCount = iQuery.InternalJoinItems.Count;

                for (int i = 0; i < joinCount; i++)
                {
                    sql += "(";
                }
            }

            if (iQuery.InternalFromQuery == null)
            {
                sql += Shared.CreateFullName(query);

                if (iQuery.JoinAlias != " ")
                {
                    sql += " " + iQuery.JoinAlias;
                }
            }
            else
            {
                IDynamicQuerySerializableInternal iSubQuery = iQuery.InternalFromQuery as IDynamicQuerySerializableInternal;

                iSubQuery.IsInSubQuery = true;

                sql += "(";
                sql += BuildQuery(std, iQuery.InternalFromQuery);
                sql += ")";

                if (iSubQuery.SubQueryAlias != " ")
                {
                    sql += " AS " + iSubQuery.SubQueryAlias;
                }

                iSubQuery.IsInSubQuery = false;
            }

            return(sql);
        }
Exemplo n.º 2
0
        protected static string GetJoinStatement(StandardProviderParameters std, tgDynamicQuerySerializable query)
        {
            string sql = String.Empty;

            IDynamicQuerySerializableInternal iQuery = query as IDynamicQuerySerializableInternal;

            if (iQuery.InternalJoinItems != null)
            {
                foreach (tgJoinItem joinItem in iQuery.InternalJoinItems)
                {
                    tgJoinItem.tgJoinItemData joinData = (tgJoinItem.tgJoinItemData)joinItem;

                    switch (joinData.JoinType)
                    {
                    case tgJoinType.InnerJoin:
                        sql += " INNER JOIN ";
                        break;

                    case tgJoinType.LeftJoin:
                        sql += " LEFT JOIN ";
                        break;

                    case tgJoinType.RightJoin:
                        sql += " RIGHT JOIN ";
                        break;

                    case tgJoinType.FullJoin:
                        sql += " FULL JOIN ";
                        break;
                    }

                    IDynamicQuerySerializableInternal iSubQuery = joinData.Query as IDynamicQuerySerializableInternal;

                    sql += Shared.CreateFullName((tgProviderSpecificMetadata)iSubQuery.ProviderMetadata);
                    sql += " " + iSubQuery.JoinAlias + " ON ";

                    foreach (tgComparison comparisonItem in joinData.WhereItems)
                    {
                        tgComparison.tgComparisonData comparisonData = (tgComparison.tgComparisonData)comparisonItem;

                        if (comparisonData.IsParenthesis)
                        {
                            if (comparisonData.Parenthesis == tgParenthesis.Open)
                            {
                                sql += "(";
                            }
                            else
                            {
                                sql += ")";
                            }

                            continue;
                        }

                        if (comparisonData.IsConjunction)
                        {
                            if (comparisonData.Conjunction == tgConjunction.And)
                            {
                                sql += " AND ";
                            }
                            else
                            {
                                sql += " OR ";
                            }

                            continue;
                        }

                        sql += GetColumnName(comparisonData.Column);

                        switch (comparisonData.Operand)
                        {
                        case tgComparisonOperand.Equal:
                            sql += " = ";
                            break;

                        case tgComparisonOperand.NotEqual:
                            sql += " <> ";
                            break;

                        case tgComparisonOperand.GreaterThan:
                            sql += " > ";
                            break;

                        case tgComparisonOperand.LessThan:
                            sql += " < ";
                            break;

                        case tgComparisonOperand.LessThanOrEqual:
                            sql += " <= ";
                            break;

                        case tgComparisonOperand.GreaterThanOrEqual:
                            sql += " >= ";
                            break;

                        case tgComparisonOperand.IsNull:
                            sql += " IS NULL ";
                            break;

                        case tgComparisonOperand.IsNotNull:
                            sql += " IS NOT NULL ";
                            break;

                        case tgComparisonOperand.In:
                            sql += " IN ";
                            break;

                        case tgComparisonOperand.NotIn:
                            sql += " NOT IN ";
                            break;
                        }

                        if (comparisonData.ComparisonColumn.Name != null)
                        {
                            sql += GetColumnName(comparisonData.ComparisonColumn);
                        }
                        else
                        {
                            tgDynamicQuerySerializable subQuery = comparisonData.Value as tgDynamicQuerySerializable;

                            if (subQuery != null)
                            {
                                sql += GetSubquerySearchCondition(subQuery) + " (" + BuildQuery(std, subQuery) + ")";
                            }
                            else if (comparisonData.Value != null)
                            {
                                // Handle Literals
                                sql += comparisonData.Value.ToString();
                            }
                        }
                    }

                    sql += ")";
                }
            }

            return(sql);
        }