private void Initialize(IDbContext dbContext)
{
_dbSchema = dbContext.PowerPlant.CreateDbSchema();
_commands = dbContext.PowerPlant.CreateCommands();
_dbSchema.DropTable(_testTable);
}
public virtual void Setup()
{
PowerPlant = DbContext.PowerPlant;
DbSchema = PowerPlant.CreateDbSchema();
ColumnFactory = PowerPlant.CreateColumnFactory();
TableName = "hmstestcolumntypes";
DbSchema.DropTable(TableName);
}
public SchemaInitializer(Config config,
IDbSchemaBuilder schemaBuilder,
IDbSchema dbSchema)
{
_config = config;
_schemaBuilder = schemaBuilder;
_dbSchema = dbSchema;
}
/// <summary>
/// Initalize schmea builder
/// </summary>
/// <param name="config">Resource configuration</param>
/// <param name="dbSchema">Schmea infomration to populate</param>
/// <param name="typeMapper">How to map db types to c# types</param>
public DbSchemaBuilderBase(
Config config,
IDbSchema dbSchema,
IDbTypeMapper typeMapper)
{
Config = config;
_dbSchema = dbSchema;
_typeMapper = typeMapper;
}
public DbAdapter(IDbSchemaBuilder schemBuilder, DynamicClassBuilder classBuilder, IDbSchema dbSchema)
{
Check.NotNull(schemBuilder, nameof(schemBuilder));
Check.NotNull(classBuilder, nameof(classBuilder));
Check.NotNull(dbSchema, nameof(dbSchema));
_dbSchemaBuilder = schemBuilder;
_dynamicClassBuilder = classBuilder;
_dbSchema = dbSchema;
}
public DynamicClassBuilder(IDbSchema schema)
{
Check.NotNull(schema, nameof(schema));
_schema = schema;
_types = new Dictionary <string, Type>();
_typeBuilders = new Dictionary <string, TypeBuilder>(StringComparer.OrdinalIgnoreCase);
ExistingAssemblies = new Dictionary <string, Type>(StringComparer.OrdinalIgnoreCase);
}
internal static View GetView(this IDbSchema dbSchema, string schemaName, string viewName)
{
try
{
return(dbSchema.Views.First(c => c.Name.ToUpperInvariant() == viewName.ToUpperInvariant() && c.Schema.ToUpperInvariant() == schemaName.ToUpperInvariant()));
}
catch (InvalidOperationException)
{
throw new ViewNotFoundException(schemaName, viewName);
}
}
protected void Setup(string tableName)
{
TestTable = tableName;
_schemaFile = tableName + ".aschema";
_dataFile = tableName + ".adata";
_writer = AWriterFactory.CreateInstance(DbContext);
_reader = AReaderFactory.CreateInstance(DbContext);
DbSchema = DbContext.PowerPlant.CreateDbSchema();
Commands = DbContext.PowerPlant.CreateCommands();
ColumnFactory = DbContext.PowerPlant.CreateColumnFactory();
Cleanup();
}
/// <summary>
/// Find a strored procedure in the schema.
/// </summary>
/// <param name="dbSchema">Schema definition to search.</param>
/// <param name="schemaName">Target schema.</param>
/// <param name="sprocName"></param>
/// <returns>The found schema definition</returns>
/// <exception cref="StoreProcedureNotFoundException"/>
public static StoredProcedure GetStoredProcedure(this IDbSchema dbSchema, string schemaName, string sprocName)
{
Check.NotNull(dbSchema, nameof(dbSchema));
try
{
return(dbSchema.StoredProcedures.First(c => c.Schema.ToUpperInvariant() == schemaName.ToUpperInvariant() && c.Name.ToUpperInvariant() == sprocName.ToUpperInvariant()));
}
catch (InvalidOperationException)
{
throw new StoreProcedureNotFoundException(schemaName, sprocName);
}
}
public void DoViews(out int totalViews, out int failedViews, IALogger tmpLogger = null)
{
IALogger logger = tmpLogger ?? new TestLogger();
totalViews = 0;
failedViews = 0;
List <IViewDefinition> viewDefinitions = new List <IViewDefinition>();
viewDefinitions.AddRange(GetViewsFromAagView());
viewDefinitions.AddRange(GetViewsFromAsysViewThatAreNotInAagView());
ICommands cmd = _dbContext.PowerPlant.CreateCommands();
IDbSchema schema = _dbContext.PowerPlant.CreateDbSchema();
IASTNodeFactory nodeFactory = new ASTNodeFactory();
IAParser parser = AParserFactory.CreateInstance(nodeFactory);
if (_dbContext.DbType == DbTypeName.Oracle)
{
parser.ExpandEmptyStrings = true;
}
IATranslator translator = ATranslatorFactory.CreateInstance(_dbContext.DbType, nodeFactory);
foreach (var view in viewDefinitions)
{
if (view.DbType != DbTypeName.Any && view.DbType != _dbContext.DbType)
{
continue;
}
totalViews++;
try
{
schema.DropView(view.ViewName);
CreateView(cmd, parser, translator, view);
logger.Write(string.Format("View '{0}' created", view.ViewName));
}
catch (Exception ex)
{
logger.Write(string.Format("ERROR: Can't create view '{0}'", view.ViewName));
logger.Write(ex.Message);
failedViews++;
}
}
}
/// <summary>
/// Find a table in the schema.
/// </summary>
/// <param name="dbSchema">Schema definition to search.</param>
/// <param name="databaseName">Target database.</param>
/// <param name="schemaName">Target schema.</param>
/// <param name="tableName">Target table.</param>
/// <returns>The found table definition.</returns>
/// <exception cref="TableNotFoundException"/>
public static Table GetTable(this IDbSchema dbSchema, string databaseName, string schemaName, string tableName)
{
Check.NotNull(dbSchema, nameof(dbSchema));
Check.NotNull(databaseName, nameof(databaseName));
Check.NotNull(schemaName, nameof(schemaName));
Check.NotNull(tableName, nameof(tableName));
try
{
return(dbSchema.Tables.First(c => c.Name.ToUpperInvariant() == tableName.ToUpperInvariant() &&
c.Schema.ToUpperInvariant() == schemaName.ToUpperInvariant() &&
c.Database.ToUpperInvariant() == databaseName.ToUpperInvariant()));
}
catch (InvalidOperationException)
{
throw new TableNotFoundException(databaseName, schemaName, tableName);
}
}
public DataTable Query(List <string> columnList, string where = "")
{
string cmdText = string.Empty;
IDbSchema dbSchema = this.Database.Parent;
StringBuilder sb = new StringBuilder();
columnList.ForEach(s => sb.AppendFormat("{0},", dbSchema.QuoteIdentifier(s)));
if (!string.IsNullOrEmpty(where))
{
cmdText = string.Format("SELECT {0} FROM {0} WHERE {2}", sb.ToString().TrimEnd(','), this.Name, where);
}
else
{
cmdText = string.Format("SELECT {0} FROM {0}", sb.ToString().TrimEnd(','), this.Name);
}
DataTable dt = dbSchema.ExecuteQuery(this.Database, cmdText).Tables[0];
return(dt);
}
public AReader(IDbContext dbContext, IALogger logger)
{
_dbContext = dbContext;
_dbSchema = _dbContext.PowerPlant.CreateDbSchema();
_logger = logger;
}
public virtual void Setup()
{
PowerPlant = DbContext.PowerPlant;
DbSchema = PowerPlant.CreateDbSchema();
}
public XmlSchema(IDbContext dbContext)
{
_dbContext = dbContext;
_dbSchema = _dbContext.PowerPlant.CreateDbSchema();
}
public OraTableCreator(IDbContext dbContext)
{
_dbContext = dbContext;
_commands = dbContext.PowerPlant.CreateCommands();
_dbSchema = _dbContext.PowerPlant.CreateDbSchema();
}
internal static string GetTableNameOrNull(this IDbSchema db, string databaseName, string schemaName, string tableName)
{
return(db.GetTableOrNull(databaseName, schemaName, tableName)?.VariableName);
}
internal static Table GetTableOrNull(this IDbSchema dbSchema, string databaseName, string schemaName, string tableName)
{
return(dbSchema.Tables.FirstOrDefault(c => c.Name.ToUpperInvariant() == tableName.ToUpperInvariant() &&
c.Schema.ToUpperInvariant() == schemaName.ToUpperInvariant() &&
c.Database.ToUpperInvariant() == databaseName.ToUpperInvariant()));
}
public Application(Config config, IDbSchema schema)
{
_config = config;
_schema = schema;
_newLineCharacter = config.NewLineCharacter;
}
public static IDbSchema GetDbSchema(DBSetting dBSetting)
{
IDbSchema result = CreateInstance <IDbSchema>(GetClassName(dBSetting.DBType.ToString(), "DbSchemaProvider"));
return(result);
}
public SchemaBuilder1(Config config, IDbSchema dbSchema, IDbTypeMapper typeMapper) : base(config, dbSchema, typeMapper)
{
Dts = new[] { new DataTable() };
}
public SchmeaBuilder2(Config config, IDbSchema dbSchema, IDbTypeMapper typeMapper) : base(config, dbSchema, typeMapper)
{
}
