/// <summary>Column list.</summary>
        /// <typeparam name="T">Generic type parameter.</typeparam>
        /// <param name="withTablePrefix">true to with table prefix.</param>
        /// <returns>A List&lt;string&gt;</returns>
        private List <string> ColumnList <T>(bool withTablePrefix = true)
        {
            var           pocoType  = typeof(T);
            var           tableName = pocoType.GetModelDefinition().ModelName;
            List <string> result    = new List <string>(pocoType.GetModelDefinition().FieldDefinitions.Count);

            foreach (var item in pocoType.GetModelDefinition().FieldDefinitions)
            {
                var name = _dialectProvider.GetQuotedColumnName(item.FieldName);

                if (item.Name != item.FieldName)
                {
                    name += " AS " + _dialectProvider.GetQuotedColumnName(item.Name);
                }

                if (withTablePrefix)
                {
                    result.Add(string.Format("{0}.{1}", _dialectProvider.GetQuotedTableName(tableName), name));
                }
                else
                {
                    result.Add(name);
                }
            }
            return(result);
        }
Example #2
0
        private TypedUpdateStatement <T> Values(object values, IEnumerable <string> onlyFields,
                                                bool addPrimaryKeyWhereCondition)
        {
            //Filter computed fields
            var fields = values.GetType().GetModelDefinition().FieldDefinitions.Where(
                fieldDef => !fieldDef.IsComputed &&
                !fieldDef.AutoIncrement &&
                !fieldDef.IsPrimaryKey);

            //Filter fields not on the onlyFields list
            if (onlyFields != null)
            {
                var fieldsArray = onlyFields as string[] ?? onlyFields.ToArray();
                fields = fields.Where(fieldDef =>
                                      fieldsArray.Contains(_dialectProvider.GetQuotedColumnName(fieldDef.Name)));
            }

            //Filters fields not in the T object
            if (typeof(T) != values.GetType())
            {
                var tmp = _modelDefinition.FieldDefinitions.Select(x => x.Name).ToArray();
                fields = fields.Where(f => tmp.Contains(f.Name));
            }

            //Retrieve new values
            foreach (var fieldDef in fields)
            {
                var pname = _dialectProvider.GetParameterName(Statement.Parameters.Count);
                Statement.UpdateFields.Add(_dialectProvider.GetQuotedColumnName(fieldDef.FieldName), pname);
                Statement.Parameters.Add(pname, fieldDef.GetValue(values));
            }

            //Add Primarykey filter if required
            if (addPrimaryKeyWhereCondition)
            {
                var pks = _modelDefinition.FieldDefinitions.Where(x => x.IsPrimaryKey).ToArray();
                foreach (var pk in pks)
                {
                    if (Statement.WhereExpression.Length > 0)
                    {
                        Statement.WhereExpression.Append(" AND ");
                    }

                    var pname = _dialectProvider.GetParameterName(Statement.Parameters.Count);
                    Statement.WhereExpression.Append(_dialectProvider.GetQuotedColumnName(pk.FieldName));
                    Statement.WhereExpression.Append("=");
                    Statement.WhereExpression.Append(pname);
                    Statement.Parameters.Add(pname, pk.GetValue(values));
                }
            }

            return(this);
        }
        public TypedDeleteStatement <T> AddPrimaryKeyWhereCondition(T values)
        {
            var pks = _modelDefinition.FieldDefinitions.Where(x => x.IsPrimaryKey).ToArray();

            if (pks.Length == 0)
            {
                pks = _modelDefinition.FieldDefinitions.ToArray();
            }

            foreach (var pk in pks)
            {
                if (Statement.WhereExpression.Length > 0)
                {
                    Statement.WhereExpression.Append(" AND ");
                }

                var pname = _dialectProvider.GetParameterName(Statement.Parameters.Count);
                Statement.WhereExpression.Append(_dialectProvider.GetQuotedColumnName(pk.FieldName));
                Statement.WhereExpression.Append("=");
                Statement.WhereExpression.Append(pname);
                Statement.Parameters.Add(pname, pk.GetValue(values));
            }

            return(this);
        }
Example #4
0
        public DynamicCountStatement Having <T>(string columnName, Expression <Func <T, bool> > predicate)
        {
            if (predicate != null)
            {
                Statement.HavingExpression.Append(
                    new ColumnWhereExpresionVisitor <T>(_dialectProvider, Statement.Parameters,
                                                        _dialectProvider.GetQuotedColumnName(columnName))
                    .VisitExpression(predicate));
            }
            else
            {
                Statement.HavingExpression.Clear();
            }

            return(this);
        }
Example #5
0
        public TypedInsertStatement <T> Values(T values, IEnumerable <string> onlyFields)
        {
            var fieldsArray = onlyFields as string[] ?? onlyFields.ToArray();

            var fields = _modelDefinition.FieldDefinitions
                         .Where(fieldDef => !fieldDef.IsComputed)
                         .Where(fieldDef => !fieldDef.AutoIncrement)
                         .Where(fieldDef => !fieldsArray.Any() || fieldsArray.Contains(fieldDef.Name)).ToList();

            foreach (var fieldDef in fields)
            {
                var v = fieldDef.GetValue(values) ?? fieldDef.DefaultValue;
                if (v != null)
                {
                    var pname = _dialectProvider.GetParameterName(Statement.Parameters.Count);
                    Statement.Parameters.Add(pname, v);
                    Statement.InsertFields.Add(_dialectProvider.GetQuotedColumnName(fieldDef.FieldName));
                }
            }

            return(this);
        }