public override string Generate(InsertDataExpression expression)
{
List <string> columnNames = new List <string>();
List <string> columnValues = new List <string>();
List <string> insertStrings = new List <string>();
foreach (InsertionDataDefinition row in expression.Rows)
{
columnNames.Clear();
columnValues.Clear();
foreach (KeyValuePair <string, object> item in row)
{
columnNames.Add(Quoter.QuoteColumnName(item.Key));
columnValues.Add(Quoter.QuoteValue(item.Value));
}
string columns = String.Join(", ", columnNames.ToArray());
string values = String.Join(", ", columnValues.ToArray());
insertStrings.Add(String.Format(InsertData
, Quoter.QuoteSchemaName(expression.SchemaName)
, Quoter.QuoteTableName(expression.TableName)
, columns
, values));
}
return(String.Join("; ", insertStrings.ToArray()));
}
public void CanInsertBinaryData()
{
var expression = new InsertDataExpression
{
TableName = "TestTable1"
};
var row1 = new { Id = 1, Name = "Just'in", Value = Encoding.ASCII.GetBytes("Just'in") };
var row2 = new { Id = 1, Name = "Na\te", Value = Encoding.ASCII.GetBytes("Na\te") };
expression.Rows.AddRange(new IDataDefinition[]
{
new ReflectedDataDefinition(row1),
new ReflectedDataDefinition(row2)
}
);
var sql = generator.Generate(expression);
var expected = "INSERT INTO `TestTable1` (`Id`, `Name`, `Value`) VALUES (1, 'Just''in', UNHEX('4A75737427696E'));";
expected += "\r\nINSERT INTO `TestTable1` (`Id`, `Name`, `Value`) VALUES (1, 'Na e', UNHEX('4E610965'));";
sql.ShouldBe(expected);
}
public override string Generate(InsertDataExpression expression)
{
string errors = ValidateAdditionalFeatureCompatibility(expression.AdditionalFeatures);
if (!string.IsNullOrEmpty(errors))
{
return(errors);
}
List <string> columnNames = new List <string>();
List <string> columnValues = new List <string>();
List <string> insertStrings = new List <string>();
foreach (InsertionDataDefinition row in expression.Rows)
{
columnNames.Clear();
columnValues.Clear();
foreach (KeyValuePair <string, object> item in row)
{
columnNames.Add(Quoter.QuoteColumnName(item.Key));
columnValues.Add(Quoter.QuoteValue(item.Value));
}
string columns = String.Join(", ", columnNames.ToArray());
string values = String.Join(", ", columnValues.ToArray());
insertStrings.Add(String.Format(InsertData, Quoter.QuoteTableName(expression.TableName), columns, values));
}
return(String.Join("; ", insertStrings.ToArray()));
}
public override string Generate(InsertDataExpression expression)
{
string errors = ValidateAdditionalFeatureCompatibility(expression.AdditionalFeatures);
if (!string.IsNullOrEmpty(errors))
{
return(errors);
}
List <string> columnNames = new List <string>();
List <string> columnValues = new List <string>();
List <string> insertStrings = new List <string>();
foreach (IDataDefinition row in expression.Rows)
{
IEnumerable <IDataValue> columnData = evaluator.Evaluate(row);
columnNames.Clear();
columnValues.Clear();
foreach (IDataValue item in columnData)
{
columnNames.Add(Quoter.QuoteColumnName(item.ColumnName));
columnValues.Add(Quoter.QuoteDataValue(item));
}
string columns = String.Join(", ", columnNames.ToArray());
string values = String.Join(", ", columnValues.ToArray());
insertStrings.Add(String.Format(InsertData, Quoter.QuoteTableName(expression.TableName), columns, values, CommandDelimiter));
}
return(String.Join(MultilineDelimiter, insertStrings.ToArray()));
}
public override void Process(Expressions.RenameTableExpression expression)
{
truncator.Truncate(expression);
FirebirdSchemaProvider schema = new FirebirdSchemaProvider(this);
TableDefinition tableDef = schema.GetTableDefinition(expression.OldName);
tableDef.Name = expression.NewName;
CreateTableExpression createNew = new CreateTableExpression()
{
TableName = expression.NewName,
SchemaName = String.Empty
};
//copy column definitions (nb: avoid to copy key names, because in firebird they must be globally unique, so let it rename)
tableDef.Columns.ToList().ForEach(x => createNew.Columns.Add(new ColumnDefinition()
{
Name = x.Name,
DefaultValue = x.DefaultValue,
IsForeignKey = x.IsForeignKey,
IsIdentity = x.IsIdentity,
IsIndexed = x.IsIndexed,
IsNullable = x.IsNullable,
IsPrimaryKey = x.IsPrimaryKey,
IsUnique = x.IsUnique,
ModificationType = x.ModificationType,
Precision = x.Precision,
Size = x.Size,
Type = x.Type,
CustomType = x.CustomType
}));
Process(createNew);
int columnCount = tableDef.Columns.Count;
string[] columns = tableDef.Columns.Select(x => x.Name).ToArray();
InsertDataExpression data = new InsertDataExpression();
using (DataSet ds = ReadTableData(String.Empty, expression.OldName))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
InsertionDataDefinition insert = new InsertionDataDefinition();
for (int i = 0; i < columnCount; i++)
{
insert.Add(new KeyValuePair <string, object>(columns[i], dr.ItemArray[i]));
}
data.Rows.Add(insert);
}
}
Process(data);
DeleteTableExpression delTable = new DeleteTableExpression()
{
TableName = expression.OldName,
SchemaName = String.Empty
};
Process(delTable);
}
public override string Generate(InsertDataExpression expression)
{
string errors = ValidateAdditionalFeatureCompatibility(expression.AdditionalFeatures);
if (!string.IsNullOrEmpty(errors))
{
return(errors);
}
var output = new StringBuilder();
foreach (var pair in GenerateColumnNamesAndValues(expression))
{
if (output.Length != 0)
{
AppendSqlStatementEndToken(output);
}
output.AppendFormat(
InsertData,
Quoter.QuoteTableName(expression.TableName, expression.SchemaName),
pair.Key,
pair.Value);
}
return(output.ToString());
}
public void CanInsertData()
{
var expression = new InsertDataExpression();
expression.TableName = "TestTable";
expression.Rows.Add(new InsertionDataDefinition
{
new KeyValuePair <string, object>("Id", 1),
new KeyValuePair <string, object>("Name", "Just'in"),
new KeyValuePair <string, object>("Website", "codethinked.com")
});
expression.Rows.Add(new InsertionDataDefinition
{
new KeyValuePair <string, object>("Id", 2),
new KeyValuePair <string, object>("Name", "Na\\te"),
new KeyValuePair <string, object>("Website", "kohari.org")
});
var sql = generator.Generate(expression);
var expected = "INSERT INTO \"public\".\"TestTable\" (\"Id\",\"Name\",\"Website\") VALUES (1,'Just''in','codethinked.com');";
expected += "INSERT INTO \"public\".\"TestTable\" (\"Id\",\"Name\",\"Website\") VALUES (2,'Na\\te','kohari.org');";
sql.ShouldBe(expected);
}
public void IdentityCanInsert()
{
using (var table = new FirebirdTestTable(Processor, null, "bogus int"))
{
Processor.Process(new CreateColumnExpression
{
TableName = table.Name,
Column = { Name = "id", IsIdentity = true, Type = DbType.Int64, IsPrimaryKey = true }
});
var insert = new InsertDataExpression {
TableName = table.Name
};
var item = new Model.InsertionDataDefinition();
item.Add(new System.Collections.Generic.KeyValuePair <string, object>("BOGUS", 0));
insert.Rows.Add(item);
Processor.Process(insert);
using (DataSet ds = Processor.ReadTableData(String.Empty, table.Name))
{
ds.Tables.Count.ShouldBe(1);
ds.Tables[0].Rows.Count.ShouldBe(1);
ds.Tables[0].Rows[0]["BOGUS"].ShouldBe(0);
ds.Tables[0].Rows[0]["id"].ShouldBe(1);
}
}
}
public void CanInsertData()
{
var expression = new InsertDataExpression {
TableName = "TestTable"
};
expression.Rows.Add(new InsertionDataDefinition {
new KeyValuePair <string, object>("Id", 1),
new KeyValuePair <string, object>("Name", "Justin"),
new KeyValuePair <string, object>("Website", "codethinked.com")
});
expression.Rows.Add(new InsertionDataDefinition {
new KeyValuePair <string, object>("Id", 2),
new KeyValuePair <string, object>("Name", "Nate"),
new KeyValuePair <string, object>("Website", "kohari.org")
});
ApplyDefaultConventions(expression);
var sql = generator.Generate(expression);
var expected = "INSERT INTO [TestTable] (Id,Name,Website) VALUES (1,'Justin','codethinked.com');";
expected += "INSERT INTO [TestTable] (Id,Name,Website) VALUES (2,'Nate','kohari.org');";
sql.ShouldBe(expected);
}
public override string Generate(InsertDataExpression expression)
{
if (compatabilityMode == CompatabilityMode.STRICT)
{
List <string> unsupportedFeatures = expression.AdditionalFeatures.Keys.Where(x => !IsAdditionalFeatureSupported(x)).ToList();
if (unsupportedFeatures.Any())
{
string errorMessage =
string.Format("The following database specific additional features are not supported in strict mode [{0}]",
expression.AdditionalFeatures.Keys.Aggregate((x, y) => x + ", " + y));
return(compatabilityMode.HandleCompatabilty(errorMessage));
}
}
List <string> columnNames = new List <string>();
List <string> columnValues = new List <string>();
List <string> insertStrings = new List <string>();
foreach (InsertionDataDefinition row in expression.Rows)
{
columnNames.Clear();
columnValues.Clear();
foreach (KeyValuePair <string, object> item in row)
{
columnNames.Add(Quoter.QuoteColumnName(item.Key));
columnValues.Add(Quoter.QuoteValue(item.Value));
}
string columns = String.Join(", ", columnNames.ToArray());
string values = String.Join(", ", columnValues.ToArray());
insertStrings.Add(String.Format(InsertData, Quoter.QuoteTableName(expression.TableName), columns, values));
}
return(String.Join("; ", insertStrings.ToArray()));
}
protected static bool IsUsingIdentityInsert(InsertDataExpression expression)
{
if (expression.AdditionalFeatures.ContainsKey(SqlServerExtensions.IdentityInsert))
{
return((bool)expression.AdditionalFeatures[SqlServerExtensions.IdentityInsert]);
}
return(false);
}
public void UpdateVersionInfo(long version)
{
var dataExpression = new InsertDataExpression();
dataExpression.Rows.Add(CreateVersionInfoInsertionData(version));
dataExpression.TableName = VersionTableMetaData.TableName;
dataExpression.SchemaName = VersionTableMetaData.SchemaName;
dataExpression.ExecuteWith(Processor);
}
public IInsertDataOrInSchemaSyntax IntoTable(string tableName)
{
var expression = new InsertDataExpression {
TableName = tableName
};
_context.Expressions.Add(expression);
return(new InsertDataExpressionBuilder(expression));
}
/// <inheritdoc />
public IInsertIntoBuilder IntoTable(string tableName)
{
var expression = new InsertDataExpression(_context)
{
TableName = tableName
};
return(new InsertIntoBuilder(expression));
}
public void CanAddCaseSensitiveColumnNames()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder.WithCaseSensitiveColumnNames();
expression.CaseSensitiveColumnNames.ShouldBeTrue();
}
public void SqlServerIdentityInsertCalledTwiceAddsCorrectAdditionalFeature()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder.WithIdentityInsert().WithIdentityInsert();
expression.AdditionalFeatures.ShouldContain(
new System.Collections.Generic.KeyValuePair<string, object>(SqlServerExtensions.IdentityInsert, true));
}
protected virtual string GetOverridingIdentityValuesString(InsertDataExpression expression)
{
if (!expression.AdditionalFeatures.ContainsKey(PostgresExtensions.OverridingIdentityValues))
{
return(string.Empty);
}
throw new NotSupportedException("The current version doesn't support OVERRIDING {SYSTEM|USER} VALUE. Please use Postgres 10+.");
}
public static InsertDataExpression GetInsertGUIDExpression()
{
var expression = new InsertDataExpression {
TableName = TestTableName1
};
expression.Rows.Add(new ExplicitDataDefinition(new DataValue("guid", TestGuid)));
return(expression);
}
public void SqlServerIdentityInsertCalledTwiceAddsCorrectAdditionalFeature()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder.WithIdentityInsert().WithIdentityInsert();
expression.AdditionalFeatures.ShouldContain(
new KeyValuePair <string, object>(SqlServerExtensions.IdentityInsert, true));
}
public IInsertDataSyntax IntoTable(string tableName)
{
var expression = new InsertDataExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax)
{
TableName = tableName
};
_context.Expressions.Add(expression);
return(new InsertDataBuilder(expression));
}
public void RowsGetSetWhenRowIsCalled()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder
.Row(new { Data1 = "Row1Data1", Data2 = "Row1Data2" })
.Row(new { Data1 = "Row2Data1", Data2 = "Row2Data2" });
expression.Rows.Count.ShouldBe(2);
}
public void CanAddDataTableAndRowsInsertedSeperately()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder
.DataTable("data.xml");
expression.DataTableFile.ShouldBe("data.xml");
expression.InsertRowsSeparately.ShouldBeTrue();
}
public override string Generate(InsertDataExpression expression)
{
if (IsUsingIdentityInsert(expression))
{
return(string.Format("{0}; {1}; {2}",
string.Format(IdentityInsert, Quoter.QuoteTableName(expression.TableName), "ON"),
base.Generate(expression),
string.Format(IdentityInsert, Quoter.QuoteTableName(expression.TableName), "OFF")));
}
return(base.Generate(expression));
}
public void RowsGetSetWhenRowIsCalled()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder
.Row(new { Data1 = "Row1Data1", Data2 = "Row1Data2" })
.Row(new { Data1 = "Row2Data1", Data2 = "Row2Data2" });
expression.Rows.Count.ShouldBe(2);
}
public void PostgresOverridingUserValueCalledTwiceAddsCorrectAdditionalFeature()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder.WithOverridingUserValue().WithOverridingUserValue();
expression.AdditionalFeatures.ShouldContain(
new KeyValuePair <string, object>(
PostgresExtensions.OverridingIdentityValues,
PostgresOverridingIdentityValuesType.User));
}
public static InsertDataExpression GetInsertEnumExpression()
{
var expression = new InsertDataExpression {
TableName = TestTableName1
};
expression.Rows.Add(new InsertionDataDefinition {
new KeyValuePair <string, object>("enum", Foo.Boo)
});
return(expression);
}
public static InsertDataExpression GetInsertGUIDExpression(Guid guid)
{
var expression = new InsertDataExpression {
TableName = TestTableName1
};
expression.Rows.Add(new InsertionDataDefinition {
new KeyValuePair <string, object>("guid", guid)
});
return(expression);
}
public override string Generate(InsertDataExpression expression)
{
string errors = ValidateAdditionalFeatureCompatibility(expression.AdditionalFeatures);
if (!string.IsNullOrEmpty(errors))
{
return(errors);
}
var insertStrings = GenerateColumnNamesAndValues(expression).Select(x => String.Format(InsertData, Quoter.QuoteTableName(expression.TableName), x.Key, x.Value));
return(String.Join("; ", insertStrings.ToArray()));
}
public void CanAddMultipleReplacementValues()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder
.WithReplacementValue(string.Empty, " ")
.WithReplacementValue(string.Empty, "Foo");
expression.ReplacementValues.Count.ShouldBe(1);
expression.ReplacementValues.ContainsKey(string.Empty).ShouldBeTrue();
expression.ReplacementValues[string.Empty].ShouldBe("Foo");
}
/// <inheritdoc />
protected override string GetOverridingIdentityValuesString(InsertDataExpression expression)
{
if (!expression.AdditionalFeatures.ContainsKey(PostgresExtensions.OverridingIdentityValues))
{
return(string.Empty);
}
var overridingIdentityValues =
expression.GetAdditionalFeature <PostgresOverridingIdentityValuesType>(
PostgresExtensions.OverridingIdentityValues);
return(string.Format(" OVERRIDING {0} VALUE",
overridingIdentityValues == PostgresOverridingIdentityValuesType.User ? "USER" : "SYSTEM"));
}
public void NonUnicodeQuotesCorrectly()
{
var expression = new InsertDataExpression {
TableName = "TestTable"
};
expression.Rows.Add(new InsertionDataDefinition
{
new KeyValuePair <string, object>("NonUnicodeStringValue", new NonUnicodeString("NonUnicodeString")),
});
var result = Generator.Generate(expression);
result.ShouldBe("INSERT INTO [dbo].[TestTable] ([NonUnicodeStringValue]) VALUES ('NonUnicodeString')");
}
public void CanInsertGuidData()
{
var gid = Guid.NewGuid();
var expression = new InsertDataExpression {
TableName = "TestTable"
};
expression.Rows.Add(new ExplicitDataDefinition(new DataValue("guid", gid)));
var sql = generator.Generate(expression);
var expected = String.Format("INSERT INTO \"TestTable\" (\"guid\") VALUES ('{0}')", gid);
sql.ShouldBe(expected);
}
public override string Generate(InsertDataExpression expression)
{
var insertStrings = new List <string>();
foreach (IDataDefinition row in expression.Rows)
{
IEnumerable <IDataValue> dataValues = evaluator.Evaluate(row).ToArray();
string columns = String.Join(", ", dataValues.Select(dataValue => Quoter.QuoteColumnName(dataValue.ColumnName)).ToArray());
string values = String.Join(", ", dataValues.Select(dataValue => Quoter.QuoteDataValue(dataValue)).ToArray());
insertStrings.Add(String.Format(InsertData, Quoter.QuoteTableName(expression.TableName), columns, values, CommandDelimiter));
}
return("INSERT ALL " + String.Join(" ", insertStrings.ToArray()) + " SELECT 1 FROM DUAL");
}
public void NonUnicodeQuotesCorrectly()
{
var expression = new InsertDataExpression {
TableName = "TestTable"
};
expression.Rows.Add(new InsertionDataDefinition
{
new KeyValuePair <string, object>("NormalString", "Just'in"),
new KeyValuePair <string, object>("UnicodeString", new NonUnicodeString("codethinked'.com"))
});
var result = Generator.Generate(expression);
result.ShouldBe("INSERT INTO TestTable (NormalString, UnicodeString) VALUES ('Just''in', 'codethinked''.com')");
}
public void ExplicitUnicodeStringIgnoredForNonSqlServer()
{
var expression = new InsertDataExpression {
TableName = "TestTable"
};
expression.Rows.Add(new InsertionDataDefinition
{
new KeyValuePair <string, object>("NormalString", "Just'in"),
new KeyValuePair <string, object>("UnicodeString", new ExplicitUnicodeString("codethinked'.com"))
});
var result = Generator.Generate(expression);
result.ShouldBe("INSERT INTO \"public\".\"TestTable\" (\"NormalString\",\"UnicodeString\") VALUES ('Just''in','codethinked''.com');");
}
public void RowsGetPopulatedWhenRowWithDictionaryIsCalled()
{
var values = new Dictionary<string, object>();
values["Data1"] = "Row1Data1";
values["Data2"] = "Row1Data2";
var expression = new InsertDataExpression();
new InsertDataExpressionBuilder(expression).Row(values);
expression.Rows.Count.ShouldBe(1);
expression.Rows[0][0].Key.ShouldBe("Data1");
expression.Rows[0][0].Value.ShouldBe("Row1Data1");
expression.Rows[0][1].Key.ShouldBe("Data2");
expression.Rows[0][1].Value.ShouldBe("Row1Data2");
}
public override string Generate(InsertDataExpression expression)
{
var result = new StringBuilder();
foreach (InsertionData row in expression.Rows)
{
List<string> columnNames = new List<string>();
List<object> columnData = new List<object>();
foreach (KeyValuePair<string, object> item in row)
{
columnNames.Add(item.Key);
columnData.Add(item.Value);
}
string columns = GetColumnList(columnNames);
string data = GetDataList(columnData);
result.Append(FormatExpression("INSERT INTO [{0}] ({1}) VALUES ({2});", expression.TableName, columns, data));
}
return result.ToString();
}
public void CanWithIdentityFalseByDefault()
{
var expression = new InsertDataExpression();
expression.WithIdentity.ShouldBeFalse();
}
public InsertDataExpressionBuilder(InsertDataExpression expression)
{
_expression = expression;
}
public IInsertDataOrInSchemaSyntax IntoTable(string tableName)
{
var expression = new InsertDataExpression { TableName = tableName };
_context.Expressions.Add(expression);
return new InsertDataExpressionBuilder(expression);
}
public void Process(InsertDataExpression expression)
{
Process(Generator.Generate(expression));
}
public void CanAddWithIdentity()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder
.WithIdentity();
expression.WithIdentity.ShouldBeTrue();
}
public void CanInsertData()
{
var expression = new InsertDataExpression();
expression.TableName = "TestTable";
expression.Rows.Add(new InsertionDataDefinition { new KeyValuePair<string, object>("Id", 1),
new KeyValuePair<string, object>("Name", "Justin"),
new KeyValuePair<string, object>("Website", "codethinked.com") });
expression.Rows.Add(new InsertionDataDefinition { new KeyValuePair<string, object>("Id", 2),
new KeyValuePair<string, object>("Name", "Nate"),
new KeyValuePair<string, object>("Website", "kohari.org") });
string sql = generator.Generate(expression);
string expected = "INSERT INTO [TestTable] (Id,Name,Website) VALUES (1,'Justin','codethinked.com');";
expected += "INSERT INTO [TestTable] (Id,Name,Website) VALUES (2,'Nate','kohari.org');";
sql.ShouldBe(expected);
}
public void CanAddWithIdentityOnColumn()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder
.WithIdentity().OnColumn("Test");
expression.WithIdentity.ShouldBeTrue();
expression.IdentityColumn.ShouldBe("Test");
}
public override string Generate(InsertDataExpression expression)
{
var result = new StringBuilder();
foreach (InsertionDataDefinition row in expression.Rows)
{
List<string> columnNames = new List<string>();
List<object> columnData = new List<object>();
foreach (KeyValuePair<string, object> item in row)
{
columnNames.Add(item.Key);
columnData.Add(item.Value);
}
string columns = GetColumnList(columnNames);
string data = GetDataList(columnData);
result.Append(String.Format(" INTO {0} ({1}) VALUES ({2})", expression.TableName, columns, data));
}
return "INSERT ALL" + result.ToString() + " SELECT 1 FROM DUAL";
}
public void CanInsertGuidData()
{
var gid = Guid.NewGuid();
var expression = new InsertDataExpression() { TableName = "TestTable" };
expression.Rows.Add(new InsertionDataDefinition { new KeyValuePair<string, object>("guid", gid) });
string sql = generator.Generate(expression);
string expected = String.Format("INSERT ALL INTO TestTable (guid) VALUES ('{0}') SELECT 1 FROM DUAL", gid.ToString());
sql.ShouldBe(expected);
}
public void InsertRowsSeparatelyFalseByDefault()
{
var expression = new InsertDataExpression();
expression.InsertRowsSeparately.ShouldBeFalse();
}
public void NoCaseSensitiveByDefault()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
expression.CaseSensitiveColumnNames.ShouldBeFalse();
}
public virtual void Process(InsertDataExpression expression)
{
if (expression.Rows != null && expression.Rows.Count == 0)
{
Announcer.Say("No data for " + expression.TableName);
return;
}
// Check if require rows to be inserted separately
// This may be required as this is a large dataset or the processor doe snot support inserting multiple
if (expression.InsertRowsSeparately && expression.Rows != null && expression.Rows.Count > 1)
{
foreach (var row in expression.Rows)
{
var insert = new InsertDataExpression()
{
CaseSensitiveColumnNames = expression.CaseSensitiveColumnNames
, CaseSensitiveColumns = expression.CaseSensitiveColumns
, DataTableFile = expression.DataTableFile
, SchemaName = expression.SchemaName
, TableName = expression.TableName
, WithIdentity = expression.WithIdentity
};
// Copy the replacement to the new item
foreach (var replacement in expression.ReplacementValues)
{
insert.ReplacementValues.Add(replacement.Key, replacement.Value);
}
insert.Rows.Add(row);
Process(Generator.Generate(insert));
}
}
else
Process(Generator.Generate(expression));
}
public abstract string Generate(InsertDataExpression expression);
private void updateVersionInfoWithAppliedMigration(long version)
{
var dataExpression = new InsertDataExpression();
dataExpression.Rows.Add(createVersionInfoInsertionData(version));
dataExpression.TableName = _versionTableMetaData.TableName;
dataExpression.ExecuteWith(_migrationProcessor);
}
public void CanInsertGuidData()
{
var gid = Guid.NewGuid();
var expression = new InsertDataExpression { TableName = "TestTable" };
expression.Rows.Add(new InsertionDataDefinition { new KeyValuePair<string, object>("guid", gid) });
var sql = generator.Generate(expression);
var expected = String.Format("INSERT INTO \"public\".\"TestTable\" (\"guid\") VALUES ('{0}');", gid);
sql.ShouldBe(expected);
}
public void CanSetInsertRowsSeparately()
{
var expression = new InsertDataExpression();
var builder = new InsertDataExpressionBuilder(expression);
builder
.InsertRowsSeparately();
expression.InsertRowsSeparately.ShouldBeTrue();
}
