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) { }