public IColumnBuilder AddColumn(IColumnConfig column)
{
var builder = this.CreateColumn(column);
this.Expressions.Add(builder);
return(builder);
}
public IBinaryExpressionBuilder AddColumn(IColumnConfig column)
{
var expression = this.Fragment <IBinaryExpressionBuilder>();
var parameter = this.CreateParameter(
Conventions.ParameterName(column),
column.ColumnType.Type,
column.ColumnType.Size,
column.ColumnType.Precision,
column.ColumnType.Scale,
ParameterDirection.Input,
false,
column,
DatabaseQueryParameterFlags.EntityRead
);
expression.Left = this.CreateColumn(column);
expression.Operator = this.CreateOperator(QueryOperator.Equal);
if (column.IsConcurrencyCheck)
{
expression.Right = this.CreateBinary(
parameter,
QueryOperator.Plus,
this.CreateConstant(1)
);
}
else
{
expression.Right = parameter;
}
this.Expressions.Add(expression);
return(expression);
}
public object this[IColumnConfig column]
{
get
{
return(this[column.Identifier]);
}
}
protected virtual IColumnBuilder VisitColumn(IColumnConfig column)
{
return(this.Peek.Write(this.Peek.CreateColumn(column).With(builder =>
{
builder.Alias = column.Identifier;
builder.Direction = this.Direction;
})));
}
public IBinaryExpressionBuilder GetColumn(IColumnConfig leftColumn, IColumnConfig rightColumn)
{
return(this.GetExpression <IBinaryExpressionBuilder>(
builder =>
builder.Left is IColumnBuilder && ColumnComparer.ColumnConfig.Equals((builder.Left as IColumnBuilder).Column, leftColumn) &&
builder.Right is IColumnBuilder && ColumnComparer.ColumnConfig.Equals((builder.Right as IColumnBuilder).Column, rightColumn)
));
}
public IColumnBuilder AddColumn(IColumnConfig column)
{
var expression = this.CreateColumn(column);
expression.Alias = column.Identifier;
this.Expressions.Add(expression);
return(expression);
}
public IColumnBuilder CreateColumn(IColumnConfig column)
{
if (column == null)
{
throw new NotImplementedException();
}
return(this.Fragment <IColumnBuilder>().With(builder => builder.Column = column));
}
public object CreateValue(ITableConfig table, IColumnConfig column, object item)
{
switch (column.ColumnType.Type)
{
case DbType.Guid:
return(SequentialGuid.New());
}
return(column.DefaultValue);
}
public IBinaryExpressionBuilder AddColumn(IColumnConfig leftColumn, IColumnConfig rightColumn)
{
var expression = this.Fragment <IBinaryExpressionBuilder>();
expression.Left = this.CreateColumn(leftColumn);
expression.Operator = this.CreateOperator(QueryOperator.Equal);
expression.Right = this.CreateColumn(rightColumn);
this.Expressions.Add(expression);
return(expression);
}
public bool TryCreateColumn(IColumnSelector selector, out IColumnConfig column)
{
column = Factories.Column.Create(this, selector);
if (!ColumnValidator.Validate(this.Config.Database, this, column))
{
return(false);
}
column = this.Columns.AddOrUpdate(column.Identifier, column);
this.Reset();
return(true);
}
public static bool Validate(IDatabase database, ITableConfig table, IColumnConfig column, ITransactionSource transaction = null)
{
if (string.IsNullOrEmpty(column.Identifier))
{
return(false);
}
if (table.Flags.HasFlag(TableFlags.ValidateSchema) && !column.Table.Config.Database.Schema.ColumnExists(column.Table.TableName, column.ColumnName, transaction))
{
return(false);
}
return(true);
}
public virtual IBinaryExpressionBuilder CreateConstraint(IColumnConfig leftColumn, IColumnConfig rightColumn)
{
return(this.Fragment <IBinaryExpressionBuilder>().With(builder =>
{
if (leftColumn != null)
{
builder.Left = builder.CreateColumn(leftColumn);
}
builder.Operator = builder.CreateOperator(QueryOperator.Equal);
if (rightColumn != null)
{
builder.Right = builder.CreateColumn(rightColumn);
}
}));
}
public bool Equals(IColumnConfig other)
{
if (other == null)
{
return(false);
}
if ((TableConfig)this.Table != (TableConfig)other.Table)
{
return(false);
}
if (!string.Equals(this.ColumnName, other.ColumnName, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
return(true);
}
public IParameterBuilder AddParameter(IColumnConfig column)
{
var expression = this.CreateParameter(
Conventions.ParameterName(column),
column.ColumnType.Type,
column.ColumnType.Size,
column.ColumnType.Precision,
column.ColumnType.Scale,
ParameterDirection.Input,
false,
column,
DatabaseQueryParameterFlags.EntityRead
);
this.Expressions.Add(expression);
return(expression);
}
public IBinaryExpressionBuilder AddColumn(IColumnConfig column)
{
var expression = this.Fragment <IBinaryExpressionBuilder>();
expression.Left = this.CreateColumn(column);
expression.Operator = this.CreateOperator(QueryOperator.Equal);
expression.Right = this.CreateParameter(
Conventions.ParameterName(column),
column.ColumnType.Type,
column.ColumnType.Size,
column.ColumnType.Precision,
column.ColumnType.Scale,
ParameterDirection.Input,
false,
column,
DatabaseQueryParameterFlags.EntityRead
);
this.Expressions.Add(expression);
return(expression);
}
public bool Populate(object item, IColumnConfig column, IDatabaseReaderRecord record)
{
if (column.Setter == null)
{
return(false);
}
var value = default(object);
if (record.TryGetValue(column, out value))
{
if (value == null || DBNull.Value.Equals(value))
{
value = null;
}
column.Setter(
item,
this.Database.Translation.GetLocalValue(column.ColumnType.Type, value)
);
return(true);
}
return(false);
}
public object this[IColumnConfig column]
{
get
{
if (!this.Contains(column))
{
throw new InvalidOperationException(string.Format("No such column \"{0}\".", column));
}
var name = Conventions.ParameterName(column);
var parameter = this.Parameters[name] as IDataParameter;
if (parameter.Value != null && !DBNull.Value.Equals(parameter.Value))
{
return(this.Database.Translation.GetLocalValue(column.ColumnType.Type, parameter.Value));
}
else
{
return(null);
}
}
set
{
if (!this.Contains(column))
{
throw new InvalidOperationException(string.Format("No such column \"{0}\".", column));
}
var name = Conventions.ParameterName(column);
var parameter = this.Parameters[name] as IDataParameter;
if (value != null)
{
parameter.Value = this.Database.Translation.GetRemoteValue(column.ColumnType.Type, value);
}
else
{
parameter.Value = DBNull.Value;
}
}
}
public bool Contains(IColumnConfig column)
{
return(this.Parameters.Contains(Conventions.ParameterName(column)));
}
public bool IsNull(IColumnConfig column)
{
return(this.IsNull(column.Identifier));
}
public bool TryGetValue(IColumnConfig column, out object value)
{
return(this.TryGetValue(column.Identifier, out value) || this.TryGetValue(column.ColumnName, out value));
}
public T Get <T>(IColumnConfig column)
{
return(this.Get <T>(column.Identifier));
}
public bool Contains(IColumnConfig column)
{
return(this.Contains(column.Identifier));
}
public static bool IsKey(IColumnConfig column, object key)
{
return(key != null && !DBNull.Value.Equals(key) && !key.Equals(column.DefaultValue));
}
protected virtual void VisitRelation(ICreateBuilder expression, IRelationBuilder relation, ITableConfig leftTable, ITableConfig rightTable, IColumnConfig leftColumn, IColumnConfig rightColumn)
{
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.ALTER);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.TABLE);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.Identifier(rightTable.TableName));
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.ADD);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.CONSTRAINT);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.Identifier(Conventions.RelationName(leftTable, rightTable)));
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.FOREIGN_KEY);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.OPEN_PARENTHESES);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.Identifier(rightColumn.ColumnName));
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.CLOSE_PARENTHESES);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.REFERENCES);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.Identifier(leftTable.TableName));
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.OPEN_PARENTHESES);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.Identifier(leftColumn.ColumnName));
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.CLOSE_PARENTHESES);
}
public IParameterBuilder CreateParameter(string name, DbType type, int size, byte precision, byte scale, ParameterDirection direction, bool isDeclared, IColumnConfig column, DatabaseQueryParameterFlags flags)
{
if (string.IsNullOrEmpty(name))
{
throw new NotImplementedException();
}
return(this.Fragment <IParameterBuilder>().With(builder =>
{
builder.Name = name;
builder.Type = type;
builder.Size = size;
builder.Precision = precision;
builder.Scale = scale;
builder.Direction = direction;
builder.IsDeclared = isDeclared;
builder.Column = column;
builder.Flags = flags;
}));
}
protected virtual bool TryGetColumn(MemberInfo member, Expression expression, out IColumnConfig result)
{
var property = member as PropertyInfo;
if (property == null)
{
result = default(IColumnConfig);
return(false);
}
var table = this.Database.Config.GetTable(TableConfig.By(expression.Type));
if (table == null)
{
result = default(IColumnConfig);
return(false);
}
result = table.GetColumn(ColumnConfig.By(property));
return(result != null);
}
public IColumnBuilder GetColumn(IColumnConfig column)
{
return(this.GetExpression <IColumnBuilder>(builder => ColumnComparer.ColumnConfig.Equals(builder.Column, column)));
}
public static T Get <T>(this IDatabaseReaderRecord record, IColumnConfig column)
{
return(record.Get <T>(column.Identifier));
}
public DatabaseQueryParameter(string name, DbType type, int size, byte precision, byte scale, ParameterDirection direction, bool isDeclared, IColumnConfig column, DatabaseQueryParameterFlags flags)
{
this.Name = name;
this.Type = type;
this.Size = size;
this.Precision = precision;
this.Scale = scale;
this.Direction = direction;
this.IsDeclared = isDeclared;
this.Column = column;
this.Flags = flags;
}
public IParameterBuilder AddParameter(string name, DbType type, int size, byte precision, byte scale, ParameterDirection direction, bool isDeclared, IColumnConfig column, DatabaseQueryParameterFlags flags)
{
var expression = this.CreateParameter(name, type, size, precision, scale, direction, isDeclared, column, flags);
this.Expressions.Add(expression);
return(expression);
}
