public override void Visit(SqlTableColumn node)
{
if (node.SqlTable == from)
{
node.ReplaceWith(SqlDml.TableColumn(to, node.Name));
}
}
private void AddComputedStaticExpression(AddValueContext addContext)
{
SqlTableColumn column = SqlDml.TableColumn(addContext.Statement.Table, addContext.Field.Column.Name);
var all = Expression.Call(Expression.Constant(parent.Session.Query), "All", new[] { typeof(T) });
MethodCallExpression selectExpression = Expression.Call(
typeof(Queryable),
"OrderBy",
addContext.Lambda.Type.GetGenericArguments(),
all,
addContext.Lambda);
QueryTranslationResult request = parent.GetRequest(parent.QueryProvider.CreateQuery <T>(selectExpression));
var sqlSelect = ((SqlSelect)request.Query);
SqlExpression ex = sqlSelect.OrderBy[0].Expression;
var placeholder = ex as SqlPlaceholder;
if (placeholder == null)
{
parent.Bindings.AddRange(request.ParameterBindings);
addContext.Statement.AddValue(column, ex);
return;
}
//hack for this case
addContext.Lambda = (LambdaExpression)addContext.Lambda.Visit((Expression e) =>
{
if (e.Type != typeof(Session))
{
return(e);
}
return(Expression.Property(addContext.Lambda.Parameters[0], "Session"));
});
AddComputedExpression(addContext);
}
public static void Compare(SqlTableDefinition definition, ExpectedTable expectedTable)
{
Assert.Equal(expectedTable.Name, definition.TableName);
Assert.Equal(expectedTable.Columns.Count, definition.Columns.Count);
if (expectedTable.Columns.All(s => !s.IsRowId))
{
Assert.Null(definition.RowIdColumn);
}
for (int i = 0; i < expectedTable.Columns.Count; i++)
{
SqlTableColumn actual = definition.Columns.ElementAt(i);
ExpectedColumn expected = expectedTable.Columns[i];
Assert.Equal(expected.ClrType, actual.DetectedType);
Assert.Equal(expected.Name, actual.Name);
Assert.Equal(expected.SqlType, actual.TypeName);
Assert.Equal(expected.IsPrimaryKey, actual.IsPartOfPrimaryKey);
if (expected.IsRowId)
{
Assert.Same(actual, definition.RowIdColumn);
}
}
}
public void SimpleCreateFromUnauthorized()
{
tableName = ObjectName.Parse("APP.test");
var columns = new SqlTableColumn[] {
new SqlTableColumn("id", PrimitiveTypes.Integer()),
new SqlTableColumn("name", PrimitiveTypes.VarChar()),
};
var expected = Is.InstanceOf <SecurityException>();
Assert.Throws(expected, () => UserQuery.CreateTable(tableName, columns));
}
public ICreateTableStatementBuilder WithColumn(SqlTableColumn column)
{
if (column == null)
{
throw new ArgumentNullException("column");
}
if (columns.ContainsKey(column.ColumnName))
{
throw new ArgumentException(String.Format("A column named '{0}' was already specified", column.ColumnName));
}
columns[column.ColumnName] = column;
return(this);
}
public void WithColumnIndex()
{
tableName = ObjectName.Parse("APP.test");
var columns = new SqlTableColumn[] {
new SqlTableColumn("id", PrimitiveTypes.Integer()),
new SqlTableColumn("name", PrimitiveTypes.VarChar())
{
IndexType = "BLIST"
},
new SqlTableColumn("date", PrimitiveTypes.TimeStamp())
{
DefaultExpression = SqlExpression.Parse("GetDate()")
}
};
AdminQuery.CreateTable(tableName, columns);
}
public void SimpleCreate()
{
tableName = ObjectName.Parse("APP.test");
var columns = new SqlTableColumn[] {
new SqlTableColumn("id", PrimitiveTypes.Integer()),
new SqlTableColumn("name", PrimitiveTypes.VarChar()),
};
AdminQuery.CreateTable(tableName, columns);
var table = AdminQuery.Access().GetTable(tableName);
Assert.IsNotNull(table);
Assert.AreEqual(2, table.TableInfo.ColumnCount);
// TODO: Assert it exists and has the structure desired...
}
private void AddConstantValue(AddValueContext addContext)
{
SqlTableColumn column = SqlDml.TableColumn(addContext.Statement.Table, addContext.Field.Column.Name);
SqlExpression value;
object constant = Expression.Lambda(addContext.Lambda.Body, null).Compile().DynamicInvoke();
if (constant == null)
{
value = SqlDml.Null;
}
else
{
QueryParameterBinding binding = parent.QueryBuilder.CreateParameterBinding(constant.GetType(), () => constant);
parent.Bindings.Add(binding);
value = binding.ParameterReference;
}
addContext.Statement.AddValue(column, value);
}
public void WithIndexedColumn_InsertSearch()
{
tableName = ObjectName.Parse("APP.test");
var columns = new SqlTableColumn[] {
new SqlTableColumn("id", PrimitiveTypes.Integer()),
new SqlTableColumn("name", PrimitiveTypes.VarChar())
{
IndexType = DefaultIndexTypes.InsertSearch
},
};
AdminQuery.CreateTable(tableName, columns);
var table = AdminQuery.Access().GetTable(tableName);
Assert.IsNotNull(table);
Assert.AreEqual(2, table.TableInfo.ColumnCount);
}
public void WithColumnDefault()
{
tableName = ObjectName.Parse("APP.test");
var columns = new SqlTableColumn[] {
new SqlTableColumn("id", PrimitiveTypes.Integer()),
new SqlTableColumn("name", PrimitiveTypes.VarChar())
{
DefaultExpression = SqlExpression.Parse("((67 * 90) + 22)")
},
new SqlTableColumn("date", PrimitiveTypes.TimeStamp())
{
DefaultExpression = SqlExpression.Parse("GetDate()")
}
};
AdminQuery.CreateTable(tableName, columns);
// TODO: Assert it exists and has the structure desired...
}
public void SqlColumnCloneTest()
{
{
SqlUserColumn c = SqlDml.Column(1);
SqlUserColumn cClone = (SqlUserColumn)c.Clone();
Assert.AreNotEqual(c, cClone);
Assert.AreNotEqual(c.Expression, cClone.Expression);
Assert.AreEqual(c.NodeType, cClone.NodeType);
Assert.AreEqual(c.Expression.NodeType, cClone.Expression.NodeType);
}
Console.WriteLine();
{
SqlTableRef t = SqlDml.TableRef(table1);
SqlTableColumn c = (SqlTableColumn)t[0];
SqlTableColumn cClone = (SqlTableColumn)c.Clone();
Assert.AreNotEqual(c, cClone);
// Assert.AreNotEqual(c.SqlTable, cClone.SqlTable);
Assert.AreEqual(c.NodeType, cClone.NodeType);
}
}
public void WithIndexedColumn_CustomIndex()
{
tableName = ObjectName.Parse("APP.test");
var query = CreateQuery(CreateAdminSession(Database));
var columns = new SqlTableColumn[] {
new SqlTableColumn("id", PrimitiveTypes.Integer()),
new SqlTableColumn("name", PrimitiveTypes.VarChar())
{
IndexType = "foo"
},
};
query.CreateTable(tableName, columns);
query.Commit();
query = CreateQuery(CreateAdminSession(Database));
var table = query.Access().GetTable(tableName);
Assert.IsNotNull(table);
Assert.AreEqual(2, table.TableInfo.ColumnCount);
}
private void AddComputedExpression(AddValueContext addContext)
{
SqlTableColumn column = SqlDml.TableColumn(addContext.Statement.Table, addContext.Field.Column.Name);
var all = Expression.Call(Expression.Constant(parent.Session.Query), "All", new[] { typeof(T) });
MethodCallExpression selectExpression = Expression.Call(
typeof(Queryable),
"OrderBy",
addContext.Lambda.Type.GetGenericArguments(),
all,
addContext.Lambda);
QueryTranslationResult request = parent.GetRequest(parent.QueryProvider.CreateQuery <T>(selectExpression));
var sqlSelect = ((SqlSelect)request.Query);
SqlExpression ex = sqlSelect.OrderBy[0].Expression;
parent.Bindings.AddRange(request.ParameterBindings);
if (parent.JoinedTableRef != null)
{
ex.AcceptVisitor(new ComputedExpressionSqlVisitor(sqlSelect.From, parent.JoinedTableRef));
}
addContext.Statement.AddValue(column, ex);
}
internal SqlTableColumn AsTableColumn()
{
var column = new SqlTableColumn(ColumnName, ColumnType)
{
IsNotNull = !IsNullable
};
if (Default != null)
{
SqlExpression defaultExpression;
if (DefaultIsExpression)
{
defaultExpression = SqlExpression.Parse((string)Default);
}
else
{
defaultExpression = SqlExpression.Constant(Field.Create(Default));
}
column.DefaultExpression = defaultExpression;
}
return(column);
}
public SqlTableColumn BuildColumn(ITypeResolver typeResolver, string tableName, IList <SqlTableConstraint> constraints)
{
var dataType = DataTypeBuilder.Build(typeResolver, DataType);
var columnInfo = new SqlTableColumn(ColumnName, dataType);
if (Default != null)
{
columnInfo.DefaultExpression = ExpressionBuilder.Build(Default);
}
if (IsIdentity)
{
columnInfo.DefaultExpression = SqlExpression.FunctionCall("UNIQUEKEY",
new[] { SqlExpression.Constant(tableName) });
columnInfo.IsIdentity = true;
}
foreach (var constraint in Constraints)
{
if (String.Equals(ConstraintTypeNames.Check, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
var exp = ExpressionBuilder.Build(constraint.CheckExpression);
constraints.Add(SqlTableConstraint.Check(null, exp));
}
else if (String.Equals(ConstraintTypeNames.ForeignKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
var fTable = constraint.ReferencedTable.Name;
var fColumn = constraint.ReferencedColumn.Text;
var onDelete = ForeignKeyAction.NoAction;
var onUpdate = ForeignKeyAction.NoAction;
if (!String.IsNullOrEmpty(constraint.OnDeleteAction))
{
onDelete = SqlCodeObjectBuilder.GetForeignKeyAction(constraint.OnDeleteAction);
}
if (!String.IsNullOrEmpty(constraint.OnUpdateAction))
{
onUpdate = SqlCodeObjectBuilder.GetForeignKeyAction(constraint.OnUpdateAction);
}
constraints.Add(SqlTableConstraint.ForeignKey(null, new[] { ColumnName }, fTable, new[] { fColumn }, onDelete, onUpdate));
}
else if (String.Equals(ConstraintTypeNames.PrimaryKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
constraints.Add(SqlTableConstraint.PrimaryKey(null, new[] { ColumnName }));
}
else if (String.Equals(ConstraintTypeNames.UniqueKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
constraints.Add(SqlTableConstraint.UniqueKey(null, new[] { ColumnName }));
}
else if (String.Equals(ConstraintTypeNames.NotNull, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
columnInfo.IsNotNull = true;
}
else if (String.Equals(ConstraintTypeNames.Null, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
columnInfo.IsNotNull = false;
}
}
return(columnInfo);
}
public static void AddColumn(this IQuery query, ObjectName tableName, SqlTableColumn column)
{
query.AlterTable(tableName, new AddColumnAction(column));
}
public override void AddValue(SqlTableColumn column, SqlExpression value)
{
update.Values.Add(column, value);
}
public virtual void Visit(SqlTableColumn node)
{
VisitInternal(node.SqlTable);
}
public abstract void AddValue(SqlTableColumn column, SqlExpression value);
public ICreateTableStatementBuilder WithColumn(SqlTableColumn column)
{
if (column == null)
throw new ArgumentNullException("column");
if (columns.ContainsKey(column.ColumnName))
throw new ArgumentException(String.Format("A column named '{0}' was already specified", column.ColumnName));
columns[column.ColumnName] = column;
return this;
}
private void AddEntityValue(AddValueContext addContext)
{
if (addContext.EntityParamExists)
{
throw new NotSupportedException("Expressions with reference to updating entity are not supported");
}
var methodCall = addContext.Descriptor.Expression as MethodCallExpression;
int i;
if (methodCall != null)
{
if (methodCall.Method.DeclaringType == typeof(QueryEndpoint) &&
methodCall.Method.Name.In("Single", "SingleOrDefault"))
{
object[] keys;
if (methodCall.Arguments[0].Type == typeof(Key) || methodCall.Arguments[0].Type.IsSubclassOf(typeof(Key)))
{
var key = (Key)methodCall.Arguments[0].Invoke();
keys = new object[key.Value.Count];
for (i = 0; i < keys.Length; i++)
{
keys[i] = key.Value.GetValue(i);
}
}
else
{
keys = (object[])methodCall.Arguments[0].Invoke();
}
i = -1;
foreach (ColumnInfo column in addContext.Field.Columns)
{
i++;
SqlExpression value;
if (keys[i] == null)
{
value = SqlDml.Null;
}
else
{
object v = keys[i];
QueryParameterBinding binding = parent.QueryBuilder.CreateParameterBinding(v.GetType(), () => v);
parent.Bindings.Add(binding);
value = binding.ParameterReference;
}
SqlTableColumn c = SqlDml.TableColumn(addContext.Statement.Table, column.Name);
addContext.Statement.AddValue(c, value);
}
return;
}
if (methodCall.Method.DeclaringType == typeof(Queryable) &&
methodCall.Method.Name.In("Single", "SingleOrDefault", "First", "FirstOrDefault"))
{
Expression exp = methodCall.Arguments[0];
TypeInfo info = parent.GetTypeInfo(addContext.Field.ValueType);
if (methodCall.Arguments.Count == 2)
{
exp = Expression.Call(
typeof(Queryable), "Where", new[] { info.UnderlyingType }, exp, methodCall.Arguments[1]);
}
exp = Expression.Call(typeof(Queryable), "Take", new[] { info.UnderlyingType }, exp, Expression.Constant(1));
i = -1;
foreach (FieldInfo field in
info.Key.Fields)
{
i++;
ParameterExpression p = Expression.Parameter(info.UnderlyingType);
LambdaExpression lambda =
Expression.Lambda(
typeof(Func <,>).MakeGenericType(info.UnderlyingType, field.ValueType),
Expression.MakeMemberAccess(p, field.UnderlyingProperty),
p);
IQueryable q =
((IQueryProvider)parent.QueryProvider).CreateQuery(
Expression.Call(typeof(Queryable), "Select", new[] { info.UnderlyingType, field.ValueType }, exp, lambda));
QueryTranslationResult request = parent.GetRequest(field.ValueType, q);
parent.Bindings.AddRange(request.ParameterBindings);
SqlTableColumn c = SqlDml.TableColumn(addContext.Statement.Table, addContext.Field.Columns[i].Name);
addContext.Statement.AddValue(c, SqlDml.SubQuery((ISqlQueryExpression)request.Query));
}
return;
}
}
i = -1;
var entity = (IEntity)Expression.Lambda(addContext.Lambda.Body, null).Compile().DynamicInvoke();
foreach (ColumnInfo column in addContext.Field.Columns)
{
i++;
SqlExpression value;
if (entity == null)
{
value = SqlDml.Null;
}
else
{
object v = entity.Key.Value.GetValue(i);
QueryParameterBinding binding = parent.QueryBuilder.CreateParameterBinding(v.GetType(), () => v);
parent.Bindings.Add(binding);
value = binding.ParameterReference;
}
SqlTableColumn c = SqlDml.TableColumn(addContext.Statement.Table, column.Name);
addContext.Statement.AddValue(c, value);
}
}
public void Visit(SqlTableColumn node)
{
}
