public override void Drop(IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var modelInfo = GetModelTablesInfo(structureSchema);
var sqlDropTableFormat = SqlStatements.GetSql("DropTable");
using (var cmd = CreateCommand(string.Empty, new DacParameter(DbSchemaInfo.Parameters.EntityNameParamPrefix, structureSchema.Name)))
{
DropIndexesTables(cmd, modelInfo.Statuses.IndexesTableStatuses, modelInfo.Names.IndexesTableNames);
if (modelInfo.Statuses.UniquesTableExists)
{
cmd.CommandText = sqlDropTableFormat.Inject(structureSchema.GetUniquesTableName());
cmd.ExecuteNonQuery();
}
if (modelInfo.Statuses.SpatialTableExists)
{
cmd.CommandText = sqlDropTableFormat.Inject(structureSchema.GetStructureTableName());
cmd.ExecuteNonQuery();
}
if (modelInfo.Statuses.StructureTableExists)
{
cmd.CommandText = sqlDropTableFormat.Inject(structureSchema.GetStructureTableName());
cmd.ExecuteNonQuery();
}
cmd.CommandText = SqlStatements.GetSql("DeleteStructureFromSisoDbIdentitiesTable");
cmd.ExecuteNonQuery();
}
}
public override IEnumerable<string> GetJsonByIds(IEnumerable<IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sqlFormat = SqlStatements.GetSql("GetJsonByIds").Inject(structureSchema.GetStructureTableName(), "{0}");
using (var cmd = CreateCommand(string.Empty))
{
foreach (var batchedIds in ids.Batch<IStructureId, IDacParameter>(MaxBatchedIdsSize, (id, batchCount) => new DacParameter(string.Concat("id", batchCount), id.Value)))
{
cmd.Parameters.Clear();
Driver.AddCommandParametersTo(cmd, batchedIds);
var paramsString = string.Join(",", batchedIds.Select(p => p.Name));
cmd.CommandText = sqlFormat.Inject(paramsString);
using (var reader = cmd.ExecuteReader(CommandBehavior.SingleResult | CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
yield return reader.GetString(0);
}
reader.Close();
}
}
}
}
public override IEnumerable <string> GetJsonByIds(IEnumerable <IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sqlFormat = SqlStatements.GetSql("GetJsonByIds").Inject(structureSchema.GetStructureTableName(), "{0}");
using (var cmd = CreateCommand(string.Empty))
{
foreach (var batchedIds in ids.Batch <IStructureId, IDacParameter>(MaxBatchedIdsSize, (id, batchCount) => new DacParameter(string.Concat("id", batchCount), id.Value)))
{
cmd.Parameters.Clear();
Driver.AddCommandParametersTo(cmd, batchedIds);
var paramsString = string.Join(",", batchedIds.Select(p => p.Name));
cmd.CommandText = sqlFormat.Inject(paramsString);
using (var reader = cmd.ExecuteReader(CommandBehavior.SingleResult | CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
yield return(reader.GetString(0));
}
reader.Close();
}
}
}
}
public string[] GenerateSql(IStructureSchema structureSchema, IndexesTableNames names, IndexesTableStatuses statuses)
{
if(statuses.AllExists)
return new string[0];
var structureTableName = structureSchema.GetStructureTableName();
var sqlTemplateNameSuffix = GetSqlTemplateNameSuffix(structureSchema.IdAccessor.IdType);
var generators = new Func<string>[]
{
() => !statuses.IntegersTableExists
? GenerateSqlFor("CreateIntegersIndexes", sqlTemplateNameSuffix, structureTableName, names.IntegersTableName)
: string.Empty,
() => !statuses.FractalsTableExists
? GenerateSqlFor("CreateFractalsIndexes", sqlTemplateNameSuffix, structureTableName, names.FractalsTableName)
: string.Empty,
() => !statuses.BooleansTableExists
? GenerateSqlFor("CreateBooleansIndexes", sqlTemplateNameSuffix, structureTableName, names.BooleansTableName)
: string.Empty,
() => !statuses.DatesTableExists
? GenerateSqlFor("CreateDatesIndexes", sqlTemplateNameSuffix, structureTableName, names.DatesTableName)
: string.Empty,
() => !statuses.GuidsTableExists
? GenerateSqlFor("CreateGuidsIndexes", sqlTemplateNameSuffix, structureTableName, names.GuidsTableName)
: string.Empty,
() => !statuses.StringsTableExists
? GenerateSqlFor("CreateStringsIndexes", sqlTemplateNameSuffix, structureTableName, names.StringsTableName)
: string.Empty,
() => !statuses.TextsTableExists
? GenerateSqlFor("CreateTextsIndexes", sqlTemplateNameSuffix, structureTableName, names.TextsTableName)
: string.Empty
};
return generators.Select(generator => generator()).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
}
protected virtual void BulkInsertStructures(IStructureSchema structureSchema, IStructure[] structures)
{
if (!structures.Any())
{
return;
}
var structureStorageSchema = new StructureStorageSchema(structureSchema, structureSchema.GetStructureTableName());
using (var structuresReader = new StructuresReader(structureStorageSchema, structures))
{
using (var bulkInserter = MainDbClient.GetBulkCopy())
{
bulkInserter.DestinationTableName = structuresReader.StorageSchema.Name;
bulkInserter.BatchSize = structures.Length;
var fields = structuresReader.StorageSchema.GetFieldsOrderedByIndex().Where(f => !f.Equals(StructureStorageSchema.Fields.RowId)).ToArray();
foreach (var field in fields)
{
bulkInserter.AddColumnMapping(field.Name, field.Name);
}
bulkInserter.Write(structuresReader);
}
}
}
public virtual IEnumerable <string> GetJsonOrderedByStructureId(IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("GetAllJson").Inject(structureSchema.GetStructureTableName());
return(YieldJson(sql));
}
public virtual int RowCount(IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("RowCount").Inject(structureSchema.GetStructureTableName());
return(ExecuteScalar <int>(sql));
}
public virtual string GetJsonByIdWithLock(IStructureId structureId, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("GetJsonByIdWithLock").Inject(structureSchema.GetStructureTableName());
return(ExecuteScalar <string>(sql, new DacParameter("id", structureId.Value)));
}
public virtual void DeleteById(IStructureId structureId, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("DeleteById").Inject(structureSchema.GetStructureTableName());
ExecuteNonQuery(sql, new DacParameter("id", structureId.Value));
}
public virtual void DeleteAll(IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("DeleteAll").Inject(structureSchema.GetStructureTableName());
ExecuteNonQuery(sql);
}
public virtual bool Exists(IStructureSchema structureSchema, IStructureId structureId)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
Ensure.That(structureId, "structureId").IsNotNull();
var sql = SqlStatements.GetSql("ExistsById").Inject(structureSchema.GetStructureTableName());
return(ExecuteScalar <int>(sql, new DacParameter("id", structureId.Value)) > 0);
}
public virtual void DeleteByQuery(IDbQuery query, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = StringExtensions.Inject(SqlStatements.GetSql("DeleteByQuery"), structureSchema.GetStructureTableName(),
query.Sql);
ExecuteNonQuery(sql, query.Parameters);
}
public virtual string GetJsonById(IStructureId structureId, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = StringExtensions.Inject(SqlStatements.GetSql("GetJsonById"), structureSchema.GetStructureTableName());
return(HasPipe
? Pipe.Reading(structureSchema, ExecuteScalar <string>(sql, new DacParameter("id", structureId.Value)))
: ExecuteScalar <string>(sql, new DacParameter("id", structureId.Value)));
}
public string GenerateSql(IStructureSchema structureSchema)
{
var sql = structureSchema.IdAccessor.IdType == IdTypes.Guid
? _sqlStrings.GetSql("CreateUniquesGuid")
: _sqlStrings.GetSql("CreateUniquesIdentity");
return sql.Inject(
structureSchema.GetStructureTableName(),
structureSchema.GetUniquesTableName());
}
public override void DeleteById(IStructureId structureId, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("DeleteById").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql, new DacParameter("id", structureId.Value)))
{
cmd.ExecuteNonQuery();
}
}
public virtual void SingleUpdateOfStructure(IStructure structure, IStructureSchema structureSchema)
{
var sql = SqlStatements.GetSql("SingleUpdateOfStructure").Inject(
structureSchema.GetStructureTableName(),
StructureStorageSchema.Fields.Json.Name,
StructureStorageSchema.Fields.Id.Name);
ExecuteNonQuery(sql,
new DacParameter(StructureStorageSchema.Fields.Json.Name, structure.Data),
new DacParameter(StructureStorageSchema.Fields.Id.Name, structure.Id.Value));
}
public string GenerateSql(IStructureSchema structureSchema)
{
var columnDefinitions = structureSchema.IndexAccessors
.Select(GenerateColumnDefinition);
var columnsString = string.Join(",", columnDefinitions);
var sql = structureSchema.IdAccessor.IdType == IdTypes.Guid
? _sqlStrings.GetSql("CreateIndexesGuid")
: _sqlStrings.GetSql("CreateIndexesIdentity");
return sql.Inject(
structureSchema.GetStructureTableName(),
structureSchema.GetIndexesTableName(),
columnsString);
}
public string GenerateSql(IStructureSchema structureSchema)
{
var isValidIdType = structureSchema.IdAccessor.IdType == IdTypes.Guid || structureSchema.IdAccessor.IdType == IdTypes.Identity;
if (!isValidIdType)
throw new NotSupportedException(
ExceptionMessages.DbSchemaUpserter_Upsert_IdTypeNotSupported.Inject(structureSchema.IdAccessor.IdType));
var tableName = structureSchema.GetStructureTableName();
var sql = structureSchema.IdAccessor.IdType == IdTypes.Guid
? _sqlStrings.GetSql("CreateStructuresGuid")
: _sqlStrings.GetSql("CreateStructuresIdentity");
return sql.Inject(tableName);
}
public string GenerateSql(IStructureSchema structureSchema)
{
var tableName = structureSchema.GetStructureTableName();
if (structureSchema.IdAccessor.IdType == StructureIdTypes.String)
return _sqlStatements.GetSql("CreateStructuresString").Inject(tableName);
if (structureSchema.IdAccessor.IdType == StructureIdTypes.Guid)
return _sqlStatements.GetSql("CreateStructuresGuid").Inject(tableName);
if (structureSchema.IdAccessor.IdType.IsIdentity())
return _sqlStatements.GetSql("CreateStructuresIdentity").Inject(tableName);
throw new SisoDbException(ExceptionMessages.SqlDbStructureSchemaBuilder_GenerateSql.Inject(structureSchema.IdAccessor.IdType));
}
public void Upsert(IStructureSchema structureSchema)
{
var structuresTableName = structureSchema.GetStructureTableName();
var indexesTableName = structureSchema.GetIndexesTableName();
var uniquesTableName = structureSchema.GetUniquesTableName();
var structuresTableExists = _dbClient.TableExists(structuresTableName);
var indexesTableExists = _dbClient.TableExists(indexesTableName);
var uniquesTableExists = _dbClient.TableExists(uniquesTableName);
if (structuresTableExists && indexesTableExists && uniquesTableExists)
{
_indexesDbSchemaSynchronizer.Synchronize(structureSchema);
_uniquesDbSchemaSynchronizer.Synchronize(structureSchema);
return;
}
var structuresSql = structuresTableExists ? "" : _structuresDbSchemaBuilder.GenerateSql(structureSchema);
var indexesSql = indexesTableExists ? "" : _indexesDbSchemaBuilder.GenerateSql(structureSchema);
var uniquesSql = uniquesTableExists ? "" : _uniquesDbSchemaBuilder.GenerateSql(structureSchema);
using (var cmd = _dbClient.CreateCommand(CommandType.Text, null,
new QueryParameter("entityHash", structureSchema.Hash),
new QueryParameter("entityName", structureSchema.Name)))
{
if (!structuresTableExists)
{
cmd.CommandText = structuresSql;
cmd.ExecuteNonQuery();
}
if (!indexesTableExists)
{
cmd.CommandText = indexesSql;
cmd.ExecuteNonQuery();
}
else
_indexesDbSchemaSynchronizer.Synchronize(structureSchema);
if (!uniquesTableExists)
{
cmd.CommandText = uniquesSql;
cmd.ExecuteNonQuery();
}
else
_uniquesDbSchemaSynchronizer.Synchronize(structureSchema);
}
}
public void DropStructureSet(IStructureSchema structureSchema)
{
lock (_upsertedSchemas)
{
_upsertedSchemas.Remove(structureSchema.Name);
var sql = _sqlStrings.GetSql("DropStructureTables").Inject(
structureSchema.GetIndexesTableName(),
structureSchema.GetStructureTableName());
using (var client = new SqlDbClient(_connectionInfo, false))
{
client.ExecuteNonQuery(CommandType.Text, sql, new QueryParameter("entityHash", structureSchema.Hash));
}
}
}
public virtual void SingleInsertStructure(IStructure structure, IStructureSchema structureSchema)
{
if (HasPipe)
{
structure.Data = Pipe.Writing(structureSchema, structure.Data);
}
var sql = SqlStatements.GetSql("SingleInsertStructure").Inject(
structureSchema.GetStructureTableName(),
StructureStorageSchema.Fields.Id.Name,
StructureStorageSchema.Fields.Json.Name);
ExecuteNonQuery(sql,
new DacParameter(StructureStorageSchema.Fields.Id.Name, structure.Id.Value),
new DacParameter(StructureStorageSchema.Fields.Json.Name, structure.Data));
}
public override void DeleteByIds(IEnumerable<IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("DeleteByIds").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql))
{
foreach (var idBatch in ids.Batch(MaxBatchedIdsSize))
{
cmd.Parameters.Clear();
cmd.Parameters.Add(Sql2008IdsTableParam.CreateIdsTableParam(structureSchema.IdAccessor.IdType, idBatch));
cmd.ExecuteNonQuery();
}
}
}
public override void DeleteByIds(IEnumerable <IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("DeleteByIds").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql))
{
foreach (var idBatch in ids.Batch(MaxBatchedIdsSize))
{
cmd.Parameters.Clear();
cmd.Parameters.Add(SqlServerIdsTableParam.CreateIdsTableParam(structureSchema.IdAccessor.IdType, idBatch));
cmd.ExecuteNonQuery();
}
}
}
public override IEnumerable<string> GetJsonByIds(IEnumerable<IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("GetJsonByIds").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql))
{
foreach (var idBatch in ids.Batch(MaxBatchedIdsSize))
{
cmd.Parameters.Clear();
cmd.Parameters.Add(SqlServerIdsTableParam.CreateIdsTableParam(structureSchema.IdAccessor.IdType, idBatch));
foreach (var data in YieldJson(structureSchema, cmd))
yield return data;
}
}
}
public override void DeleteByIds(IEnumerable<IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sqlFormat = SqlStatements.GetSql("DeleteByIds").Inject(structureSchema.GetStructureTableName(), "{0}");
using (var cmd = CreateCommand(string.Empty))
{
foreach (var batchedIds in ids.Batch<IStructureId, IDacParameter>(MaxBatchedIdsSize, (id, batchCount) => new DacParameter(string.Concat("id", batchCount), id.Value)))
{
cmd.Parameters.Clear();
Driver.AddCommandParametersTo(cmd, batchedIds);
var paramsString = string.Join(",", batchedIds.Select(p => p.Name));
cmd.CommandText = sqlFormat.Inject(paramsString);
cmd.ExecuteNonQuery();
}
}
}
public override void DeleteByIds(IEnumerable <IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sqlFormat = SqlStatements.GetSql("DeleteByIds").Inject(structureSchema.GetStructureTableName(), "{0}");
using (var cmd = CreateCommand(string.Empty))
{
foreach (var batchedIds in ids.Batch <IStructureId, IDacParameter>(MaxBatchedIdsSize, (id, batchCount) => new DacParameter(string.Concat("id", batchCount), id.Value)))
{
cmd.Parameters.Clear();
Driver.AddCommandParametersTo(cmd, batchedIds);
var paramsString = string.Join(",", batchedIds.Select(p => p.Name));
cmd.CommandText = sqlFormat.Inject(paramsString);
cmd.ExecuteNonQuery();
}
}
}
public override IEnumerable <string> GetJsonByIds(IEnumerable <IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("GetJsonByIds").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql))
{
foreach (var idBatch in ids.Batch(MaxBatchedIdsSize))
{
cmd.Parameters.Clear();
cmd.Parameters.Add(SqlServerIdsTableParam.CreateIdsTableParam(structureSchema.IdAccessor.IdType, idBatch));
foreach (var data in YieldJson(structureSchema, cmd))
{
yield return(data);
}
}
}
}
public string GenerateSql(IStructureSchema structureSchema)
{
var tableName = structureSchema.GetStructureTableName();
if (structureSchema.IdAccessor.IdType.IsString())
{
return(_sqlStatements.GetSql("CreateStructuresString").Inject(tableName));
}
if (structureSchema.IdAccessor.IdType.IsGuid())
{
return(_sqlStatements.GetSql("CreateStructuresGuid").Inject(tableName));
}
if (structureSchema.IdAccessor.IdType.IsIdentity())
{
return(_sqlStatements.GetSql("CreateStructuresIdentity").Inject(tableName));
}
throw new SisoDbException(ExceptionMessages.SqlDbStructureSchemaBuilder_GenerateSql.Inject(structureSchema.IdAccessor.IdType));
}
public string GenerateSql(IStructureSchema structureSchema)
{
var uniquesTableName = structureSchema.GetUniquesTableName();
var structureTableName = structureSchema.GetStructureTableName();
if (structureSchema.IdAccessor.IdType == StructureIdTypes.String)
{
return(_sqlStatements.GetSql("CreateUniquesString").Inject(uniquesTableName, structureTableName));
}
if (structureSchema.IdAccessor.IdType == StructureIdTypes.Guid)
{
return(_sqlStatements.GetSql("CreateUniquesGuid").Inject(uniquesTableName, structureTableName));
}
if (structureSchema.IdAccessor.IdType.IsIdentity())
{
return(_sqlStatements.GetSql("CreateUniquesIdentity").Inject(uniquesTableName, structureTableName));
}
throw new SisoDbException(ExceptionMessages.SqlDbUniquesSchemaBuilder_GenerateSql.Inject(structureSchema.IdAccessor.IdType));
}
public override void Drop(IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var indexesTableNames = structureSchema.GetIndexesTableNames();
var sql = SqlStatements.GetSql("DropStructureTables").Inject(
indexesTableNames.IntegersTableName,
indexesTableNames.FractalsTableName,
indexesTableNames.BooleansTableName,
indexesTableNames.DatesTableName,
indexesTableNames.GuidsTableName,
indexesTableNames.StringsTableName,
indexesTableNames.TextsTableName,
structureSchema.GetUniquesTableName(),
structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql, new DacParameter("entityName", structureSchema.Name)))
{
cmd.ExecuteNonQuery();
}
}
protected virtual string GetUpsertTableSql(IStructureSchema structureSchema)
{
var tableName = structureSchema.GetSpatialTableName();
var structureTableName = structureSchema.GetStructureTableName();
if (structureSchema.IdAccessor.IdType.IsIdentity())
{
return(SqlStatements.GetSql("UpsertSpatialTableWithIdentity").Inject(tableName, structureTableName));
}
if (structureSchema.IdAccessor.IdType.IsGuid())
{
return(SqlStatements.GetSql("UpsertSpatialTableWithGuid").Inject(tableName, structureTableName));
}
if (structureSchema.IdAccessor.IdType.IsString())
{
return(SqlStatements.GetSql("UpsertSpatialTableWithString").Inject(tableName, structureTableName));
}
throw new SisoDbException(ExceptionMessages.IdTypeNotSupported.Inject(structureSchema.IdAccessor.IdType));
}
public override IEnumerable <string> GetJsonByIds(IEnumerable <IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("GetJsonByIds").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql))
{
foreach (var idBatch in ids.Batch(MaxBatchedIdsSize))
{
cmd.Parameters.Clear();
cmd.Parameters.Add(SqlServerIdsTableParam.CreateIdsTableParam(structureSchema.IdAccessor.IdType, idBatch));
using (var reader = cmd.ExecuteReader(CommandBehavior.SingleResult | CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
yield return(reader.GetString(0));
}
reader.Close();
}
}
}
}
public string[] GenerateSql(IStructureSchema structureSchema, IndexesTableNames names, IndexesTableStatuses statuses)
{
if (statuses.AllExists)
{
return(new string[0]);
}
var structureTableName = structureSchema.GetStructureTableName();
var sqlTemplateNameSuffix = GetSqlTemplateNameSuffix(structureSchema.IdAccessor.IdType);
var generators = new Func <string>[]
{
() => !statuses.IntegersTableExists
? GenerateSqlFor("CreateIntegersIndexes", sqlTemplateNameSuffix, structureTableName, names.IntegersTableName)
: string.Empty,
() => !statuses.FractalsTableExists
? GenerateSqlFor("CreateFractalsIndexes", sqlTemplateNameSuffix, structureTableName, names.FractalsTableName)
: string.Empty,
() => !statuses.BooleansTableExists
? GenerateSqlFor("CreateBooleansIndexes", sqlTemplateNameSuffix, structureTableName, names.BooleansTableName)
: string.Empty,
() => !statuses.DatesTableExists
? GenerateSqlFor("CreateDatesIndexes", sqlTemplateNameSuffix, structureTableName, names.DatesTableName)
: string.Empty,
() => !statuses.GuidsTableExists
? GenerateSqlFor("CreateGuidsIndexes", sqlTemplateNameSuffix, structureTableName, names.GuidsTableName)
: string.Empty,
() => !statuses.StringsTableExists
? GenerateSqlFor("CreateStringsIndexes", sqlTemplateNameSuffix, structureTableName, names.StringsTableName)
: string.Empty,
() => !statuses.TextsTableExists
? GenerateSqlFor("CreateTextsIndexes", sqlTemplateNameSuffix, structureTableName, names.TextsTableName)
: string.Empty
};
return(generators.Select(generator => generator()).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray());
}
public override IEnumerable<string> GetJsonByIds(IEnumerable<IStructureId> ids, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("GetJsonByIds").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql))
{
foreach (var idBatch in ids.Batch(MaxBatchedIdsSize))
{
cmd.Parameters.Clear();
cmd.Parameters.Add(SqlServerIdsTableParam.CreateIdsTableParam(structureSchema.IdAccessor.IdType, idBatch));
using (var reader = cmd.ExecuteReader(CommandBehavior.SingleResult | CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
yield return reader.GetString(0);
}
reader.Close();
}
}
}
}
protected virtual void BulkInsertStructures(IStructureSchema structureSchema, IStructure[] structures)
{
if (!structures.Any())
return;
var structureStorageSchema = new StructureStorageSchema(structureSchema, structureSchema.GetStructureTableName());
using (var structuresReader = new StructuresReader(structureStorageSchema, structures))
{
using (var bulkInserter = MainDbClient.GetBulkCopy())
{
bulkInserter.DestinationTableName = structuresReader.StorageSchema.Name;
bulkInserter.BatchSize = structures.Length;
var fields = structuresReader.StorageSchema.GetFieldsOrderedByIndex().Where(f => !f.Equals(StructureStorageSchema.Fields.RowId)).ToArray();
foreach (var field in fields)
bulkInserter.AddColumnMapping(field.Name, field.Name);
bulkInserter.Write(structuresReader);
}
}
}
public virtual void BulkInsertStructures(IStructureSchema structureSchema, IStructure[] structures)
{
if (!structures.Any())
{
return;
}
if (HasPipe)
{
foreach (var structure in structures)
{
structure.Data = Pipe.Writing(structureSchema, structure.Data);
}
}
using (var structuresReader = new StructuresReader(new StructureStorageSchema(structureSchema, structureSchema.GetStructureTableName()), structures))
{
using (var bulkInserter = GetBulkCopy())
{
bulkInserter.DestinationTableName = structuresReader.StorageSchema.Name;
bulkInserter.BatchSize = structures.Length;
var fields = structuresReader.StorageSchema.GetFieldsOrderedByIndex().Where(f => !f.Equals(StructureStorageSchema.Fields.RowId)).ToArray();
foreach (var field in fields)
{
bulkInserter.AddColumnMapping(field.Name, field.Name);
}
bulkInserter.Write(structuresReader);
}
}
}
internal StructureStorageSchema(IStructureSchema structureSchema)
: base(structureSchema, structureSchema.GetStructureTableName())
{
}
public override int RowCount(IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("RowCount").Inject(structureSchema.GetStructureTableName());
return ExecuteScalar<int>(sql);
}
public override int RowCountByQuery(IStructureSchema structureSchema, DbQuery query)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("RowCountByQuery").Inject(structureSchema.GetStructureTableName(), query.Sql);
return ExecuteScalar<int>(sql, query.Parameters.ToArray());
}
public override void DeleteByQuery(DbQuery query, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("DeleteByQuery").Inject(
structureSchema.GetStructureTableName(),
query.Sql);
using (var cmd = CreateCommand(sql, query.Parameters.ToArray()))
{
cmd.ExecuteNonQuery();
}
}
public override void DeleteWhereIdIsBetween(IStructureId structureIdFrom, IStructureId structureIdTo, IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var sql = SqlStatements.GetSql("DeleteWhereIdIsBetween").Inject(structureSchema.GetStructureTableName());
using (var cmd = CreateCommand(sql, new DacParameter("idFrom", structureIdFrom.Value), new DacParameter("idTo", structureIdTo.Value)))
{
cmd.ExecuteNonQuery();
}
}
public static void should_not_have_been_deleted_from_structures_table(this ITestDbUtils db, IStructureSchema structureSchema, object structureId)
{
db.RowCount(structureSchema.GetStructureTableName(), "{0} = '{1}'".Inject(StructureStorageSchema.Fields.Id.Name, structureId)).ShouldEqual(1);
}
public override void Drop(IStructureSchema structureSchema)
{
Ensure.That(structureSchema, "structureSchema").IsNotNull();
var modelInfo = GetModelTablesInfo(structureSchema);
var sqlDropTableFormat = SqlStatements.GetSql("DropTable");
using (var cmd = CreateCommand(string.Empty, new DacParameter(DbSchemas.Parameters.EntityNameParamPrefix, structureSchema.Name)))
{
DropIndexesTables(cmd, modelInfo.Statuses.IndexesTableStatuses, modelInfo.Names.IndexesTableNames);
if (modelInfo.Statuses.UniquesTableExists)
{
cmd.CommandText = sqlDropTableFormat.Inject(structureSchema.GetUniquesTableName());
cmd.ExecuteNonQuery();
}
if (modelInfo.Statuses.StructureTableExists)
{
cmd.CommandText = sqlDropTableFormat.Inject(structureSchema.GetStructureTableName());
cmd.ExecuteNonQuery();
}
cmd.CommandText = SqlStatements.GetSql("DeleteStructureFromSisoDbIdentitiesTable");
cmd.ExecuteNonQuery();
}
}
