public DatabaseMetadata(DbConnection connection, Dialect.Dialect dialect, bool extras)
{
schemaReader = new InformationSchemaReader(connection);
this.extras = extras;
InitSequences(connection, dialect);
sqlExceptionConverter = dialect.BuildSQLExceptionConverter();
}
public static JSONSchema <T> Of(ISchemaDefinition <T> schemaDefinition)
{
ISchemaReader <T> Reader = schemaDefinition.SchemaReaderOpt.GetOrElse(new JsonReader <T>(_jsonMapper));
ISchemaWriter <T> Writer = schemaDefinition.SchemaWriterOpt.GetOrElse(new JsonWriter <T>(_jsonMapper));
return(new JSONSchema <T>(SchemaUtils.ParseSchemaInfo(schemaDefinition, SchemaType.JSON), schemaDefinition.Pojo, Reader, Writer));
}
internal Weaver(
ISchemaReader importAdapter,
IClassWriter exportAdapter)
{
SchemaReader = importAdapter;
Writer = exportAdapter;
}
/// <summary>
/// Loads the model using the information on the given resource to locate it.
/// </summary>
public static IPatternModelInfo Load(this ISchemaReader reader, ISchemaResource resource)
{
Guard.NotNull(() => reader, reader);
Guard.NotNull(() => resource, resource);
return(reader.Load(resource.CreateStream()));
}
public DatabaseExplorerController(ISchemaReader schemaReader,
IConnectionstringBuilder connectionstringBuilder,
IConnectionstringArgumentsMapperFactory connectionstringArgumentsMapperFactory)
{
_schemaReader = schemaReader;
_connectionstringBuilder = connectionstringBuilder;
_connectionstringArgumentsMapperFactory = connectionstringArgumentsMapperFactory;
}
public void Initialize()
{
this.mockExtension = new Mock <IInstalledExtension>();
this.extension = mockExtension.Object;
this.reader = new Mock <ISchemaReader>().Object;
this.resource = new Mock <ISchemaResource>().Object;
this.target = new InstalledToolkitInfo(this.extension, this.reader, this.resource);
}
public void Initialize()
{
this.mockExtension = new Mock<IInstalledExtension>();
this.extension = mockExtension.Object;
this.reader = new Mock<ISchemaReader>().Object;
this.resource = new Mock<ISchemaResource>().Object;
this.target = new InstalledToolkitInfo(this.extension, this.reader, this.resource);
}
public void SetUp()
{
var foreignKeyMapper = new ForeignKeyMapper();
var columnMapper = new ColumnMapper();
var indexMapper = new IndexMapper();
_databaseSchemaReader = new GigaWebSolution.DatabaseSchemaReader.SchemaReader(foreignKeyMapper, columnMapper, indexMapper);
}
private static IEnumerable<IInstalledToolkitInfo> GetInstalledToolkits(IExtensionManager extensionManager, ISchemaReader reader)
{
Guard.NotNull(() => extensionManager, extensionManager);
return extensionManager.GetInstalledExtensions()
.Where(extension => IsToolkit(extension))
.Select(extension => TryCreateRegistration(reader, extension))
.Where(registration => registration != null);
}
public DataCopy(ISchemaReader schemaReader, ISchemaConverter schemaConverter, IDbRepositoryFactory repositoryFactory, ITableBulkCopy tableBulkCopy, IEnumerable <IEntityFilter> entityFilters, IEntityTableFactory entityTableFactory)
{
_schemaReader = schemaReader;
_schemaConverter = schemaConverter;
_repositoryFactory = repositoryFactory;
_entityFilters = entityFilters;
_tableBulkCopy = tableBulkCopy;
_entityTableFactory = entityTableFactory;
}
public GenerationProcessor(
IGeneratorStore generatorStore,
ISchemaReader schemaReader,
IGeneratorWriterFactory generatorWriterFactory)
{
_generatorStore = generatorStore.VerifyNotNull(nameof(generatorStore));
_schemaReader = schemaReader.VerifyNotNull(nameof(schemaReader));
_generatorWriterFactory = generatorWriterFactory.VerifyNotNull(nameof(generatorWriterFactory));
}
public EdmModelBuilder(ISchemaReader schemaReader)
{
if (schemaReader == null)
{
throw new ArgumentNullException(nameof(schemaReader));
}
_schemaReader = schemaReader;
}
public DataCopy(ISchemaReader schemaReader, ISchemaConverter schemaConverter, IDbRepositoryFactory repositoryFactory, ITableBulkCopy tableBulkCopy, IEnumerable<IEntityFilter> entityFilters, IEntityTableFactory entityTableFactory)
{
_schemaReader = schemaReader;
_schemaConverter = schemaConverter;
_repositoryFactory = repositoryFactory;
_entityFilters = entityFilters;
_tableBulkCopy = tableBulkCopy;
_entityTableFactory = entityTableFactory;
}
/// <summary>
/// Loads the model from the given model file.
/// </summary>
public static IPatternModelInfo Load(this ISchemaReader reader, string modelFile)
{
Guard.NotNull(() => reader, reader);
Guard.NotNullOrEmpty(() => modelFile, modelFile);
using (var stream = new FileStream(modelFile, FileMode.Open))
{
return(reader.Load(stream));
}
}
public GithubDrawer(
ISchemaReader schemaReader,
IPointPositionCalculator pointPositionCalculator,
ICommitCreator commitCreator
)
{
_schemaReader = schemaReader;
_pointPositionCalculator = pointPositionCalculator;
_commitCreator = commitCreator;
}
public SchemaDefinitionImpl(Type pojo, string jsonDef, bool alwaysAllowNull, IDictionary <string, string> properties, bool supportSchemaVersioning, bool jsr310ConversionEnabled, ISchemaReader <T> reader, ISchemaWriter <T> writer)
{
_alwaysAllowNull = alwaysAllowNull;
_properties = properties;
_jsonDef = jsonDef;
_pojo = pojo;
_supportSchemaVersioning = supportSchemaVersioning;
_jsr310ConversionEnabled = jsr310ConversionEnabled;
_reader = reader;
_writer = writer;
}
/// <summary>
/// Initializes a new instance of the <see cref="InstalledToolkitInfo"/> class.
/// </summary>
/// <param name="extension">The extension.</param>
/// <param name="reader">The reader.</param>
/// <param name="resource">The resource.</param>
public InstalledToolkitInfo(IInstalledExtension extension, ISchemaReader reader, ISchemaResource resource)
{
Guard.NotNull(() => extension, extension);
Guard.NotNull(() => reader, reader);
Guard.NotNull(() => resource, resource);
this.Extension = extension;
this.reader = reader;
this.resource = resource;
this.PatternIconPath = null;
this.ToolkitIconPath = GetIconFromExtension(extension);
}
/// <summary>
/// Initializes a new instance of the <see cref="InstalledToolkitInfo"/> class.
/// </summary>
/// <param name="extension">The extension.</param>
/// <param name="reader">The reader.</param>
/// <param name="resource">The resource.</param>
public InstalledToolkitInfo(IInstalledExtension extension, ISchemaReader reader, ISchemaResource resource)
{
Guard.NotNull(() => extension, extension);
Guard.NotNull(() => reader, reader);
Guard.NotNull(() => resource, resource);
this.Extension = extension;
this.reader = reader;
this.resource = resource;
this.PatternIconPath = null;
this.ToolkitIconPath = GetIconFromExtension(extension);
}
public SchemaReaderShould(ITestOutputHelper outputHelper) : base(outputHelper)
{
SchemaReader = Container.Resolve <ISchemaReader>();
CorrectTestData = "0000000000000000000000000000000000000000000000000000" +
"\n0000000000000000000000000000000000000000000000000000" +
"\n0000000000000000000000000000000000000000000000000000" +
"\n0000000000000000000000000000000000000000000000000000" +
"\n0000000000000000000000000000000000000000000000000000" +
"\n0000000000000000000000000000000000000000000000000000" +
"\n0000000000000000000000000000000000000000000000000000" +
"\n";
}
public EdmObjectHierarchyModelBuilder(ISchemaReader schemaReader, char separator)
{
if (schemaReader == null)
{
throw new ArgumentNullException(nameof(schemaReader));
}
if (separator <= 0)
{
throw new ArgumentOutOfRangeException(nameof(separator));
}
_schemaReader = schemaReader;
_separator = separator;
}
private static InstalledToolkitInfo TryCreateRegistration(ISchemaReader reader, IInstalledExtension extension)
{
try
{
var resource = AsSchemaResource(extension);
return new InstalledToolkitInfo(extension, reader, resource);
}
catch (Exception ex)
{
if (Microsoft.VisualStudio.ErrorHandler.IsCriticalException(ex))
throw;
tracer.Warn(Resources.InstalledToolkitAdapter_FailedToCreateRegistration, extension.InstallPath);
return null;
}
}
public DomainModelProvider(
ISchemaReader schemaReader,
IEntityInfoAdapterFactory entityInfoAdapterFactory,
IPropertyInfoAdapterFactory propertyInfoAdapterFactory,
INavigationPropertyInfoAdapterFactory navigationPropertyInfoAdapterFactory,
IIIdentifierGenerationServiceFactory identifierGenerationServiceFactory,
IPluralizationService pluralizationService,
IReverseEngineeringConfiguration configuration)
{
this.schemaReader = schemaReader;
this.entityInfoAdapterFactory = entityInfoAdapterFactory;
this.navigationPropertyInfoAdapterFactory = navigationPropertyInfoAdapterFactory;
this.propertyInfoAdapterFactory = propertyInfoAdapterFactory;
this.configuration = configuration;
this.identifierGenerationService = identifierGenerationServiceFactory.Create(pluralizationService, configuration);
}
private void AddForeignKey(DataRow rs, ISchemaReader meta)
{
String fk = (string)rs["CONSTRAINT_NAME"];
if (fk == null) return;
ForeignKeyMetadata info = GetForeignKeyMetadata(fk);
if (info == null)
{
info = new ForeignKeyMetadata(rs);
foreignKeys.Add(info.getName().ToLower(), info);
}
foreach (DataRow row in meta.GetIndexColumns(schema, name, fk).Rows)
{
info.AddColumn(GetColumnMetadata((string)row["COLUMN_NAME"]));
}
}
/// <summary>
/// Default Constructor
/// </summary>
public SqlDataWriter(ISchemaReader reader, IExecutor executor, string tableName)
{
if (null == reader)
{
throw new ArgumentNullException("reader");
}
if (null == executor)
{
throw new ArgumentNullException("executor");
}
if (string.IsNullOrWhiteSpace(tableName))
{
throw new ArgumentException("tableName");
}
this.reader = reader;
this.executor = executor;
this.tableName = tableName;
}
/// <summary>
/// Default Constructor
/// </summary>
public SqlDataWriter(ISchemaReader reader, IExecutor executor, string tableName)
{
if (null == reader)
{
throw new ArgumentNullException("reader");
}
if (null == executor)
{
throw new ArgumentNullException("executor");
}
if (string.IsNullOrWhiteSpace(tableName))
{
throw new ArgumentException("tableName");
}
this.reader = reader;
this.executor = executor;
this.tableName = tableName;
}
private static InstalledToolkitInfo TryCreateRegistration(ISchemaReader reader, IInstalledExtension extension)
{
try
{
var resource = AsSchemaResource(extension);
return(new InstalledToolkitInfo(extension, reader, resource));
}
catch (Exception ex)
{
if (Microsoft.VisualStudio.ErrorHandler.IsCriticalException(ex))
{
throw;
}
tracer.Warn(Resources.InstalledToolkitAdapter_FailedToCreateRegistration, extension.InstallPath);
return(null);
}
}
internal TableMetadata(DataRow rs, ISchemaReader meta, bool extras)
{
schema = (string)rs["TABLE_SCHEMA"];
name = (string)rs["TABLE_NAME"];
InitColumns(meta);
if (extras)
{
InitForeignKeys(meta);
InitIndexes(meta);
}
String schem = schema == null ? "" : schema + '.';
log.Info("table found: " + schem + name);
log.Info("columns: " + StringHelper.CollectionToString(columns.Keys));
if (extras)
{
log.Info("foreign keys: " + StringHelper.CollectionToString(foreignKeys.Keys));
log.Info("indexes: " + StringHelper.CollectionToString(indexes.Keys));
}
}
/// <summary>
/// Default Constructor
/// </summary>
public SqlDataReader(IExecutor executor, ISchemaReader schemaReader, IDynamicLoader loader, string sqlTableName)
{
if (null == executor)
{
throw new ArgumentNullException("executor");
}
if (null == schemaReader)
{
throw new ArgumentNullException("schemaReader");
}
if (null == loader)
{
throw new ArgumentNullException("loader");
}
if (string.IsNullOrWhiteSpace(sqlTableName))
{
throw new ArgumentException("sqlTableName");
}
this.executor = executor;
this.sqlSchemaReader = schemaReader;
this.loader = loader;
this.sqlTableName = sqlTableName;
}
public void Initialize()
{
var mock = new Mock <IInstalledExtension>();
mock.Setup(ext => ext.InstallPath).Returns(@"X:\");
mock.Setup(ext => ext.Content).Returns(
new[]
{
Mocks.Of <IExtensionContent>().First(c => c.ContentTypeName == InstalledToolkitInfo.PatternModelCustomExtensionName && c.RelativePath == @"Foo.patterndefinition" && c.Attributes == new Dictionary <string, string> {
{ SchemaResource.AssemblyFileProperty, "Test.dll" }
}),
Mocks.Of <IExtensionContent>().First(c => c.ContentTypeName == "Other" && c.RelativePath == @"Documentation\Other.docx" && c.Attributes == new Dictionary <string, string> {
{ "IsCustomizable", bool.TrueString }
}),
Mocks.Of <IExtensionContent>().First(c => c.ContentTypeName == "Other" && c.RelativePath == @"Sample.file" && c.Attributes == new Dictionary <string, string> {
{ "IsCustomizable", bool.TrueString }
}),
});
this.extension = mock.Object;
this.reader = new Mock <ISchemaReader>().Object;
this.resource = new Mock <ISchemaResource>().Object;
this.target = new InstalledToolkitInfo(this.extension, this.reader, this.resource);
}
/// <summary>
/// Default Constructor
/// </summary>
public SqlDataReader(IExecutor executor, ISchemaReader schemaReader, IDynamicLoader loader, string sqlTableName)
{
if (null == executor)
{
throw new ArgumentNullException("executor");
}
if (null == schemaReader)
{
throw new ArgumentNullException("schemaReader");
}
if (null == loader)
{
throw new ArgumentNullException("loader");
}
if (string.IsNullOrWhiteSpace(sqlTableName))
{
throw new ArgumentException("sqlTableName");
}
this.executor = executor;
this.sqlSchemaReader = schemaReader;
this.loader = loader;
this.sqlTableName = sqlTableName;
}
private void InitForeignKeys(ISchemaReader meta)
{
foreach (DataRow row in meta.GetForeignKeys(schema, name).Rows)
{
AddForeignKey(row, meta);
}
}
private void InitIndexes(ISchemaReader meta)
{
foreach (DataRow row in meta.GetIndexInfo(schema, name).Rows)
{
AddIndex(row, meta);
}
}
/// <summary>
/// Assigns a reader for working on a schema
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="reader"></param>
public void AssignReader <T>(T reader) where T : ISchemaReader
{
_reader = reader;
}
public Tokenizer(ISchemaReader reader)
{
_reader = reader;
}
private JSONSchema(ISchemaInfo SchemaInfo, Type pojo, ISchemaReader <T> reader, ISchemaWriter <T> writer) : base(SchemaInfo)
{
_pojo = pojo;
Writer = writer;
Reader = reader;
}
public ConfigurationCreator(Cfg cfg, ISchemaReader schemaReader)
{
_cfg = cfg;
_schemaReader = schemaReader;
}
public void SetUpFixture()
{
var connectionString = ConfigurationManager.ConnectionStrings["TestDatabase"].ConnectionString;
this.schemaReader = new SqlServerSchemaReader(connectionString);
}
public EdmObjectHierarchyModelBuilder(ISchemaReader schemaReader)
: this(schemaReader, '.')
{
}
public IndexHelper(ISchemaReader schemaReader, IIndexMetadataFactory indexMetadataFactory)
{
this.schemaReader = schemaReader;
this.indexMetadataFactory = indexMetadataFactory;
}
public ISchemaDefinitionBuilder <T> WithSchemaReader(ISchemaReader <T> reader)
{
_reader = reader;
return(this);
}
private void InitializeDatabaseSchemaReader()
{
var foreignKeyMapper = new ForeignKeyMapper();
var columnMapper = new ColumnMapper();
var indexMapper = new IndexMapper();
_databaseSchemaReader = new GigaWebSolution.DatabaseSchemaReader.SchemaReader(foreignKeyMapper, columnMapper, indexMapper);
}
public EdmModelBuilder(ISchemaReader schemaReader)
{
_schemaReader = schemaReader;
}
private void AddIndex(DataRow rs, ISchemaReader meta)
{
String index = (string)rs["INDEX_NAME"];
if (index == null) return;
IndexMetadata info = GetIndexMetadata(index);
if (info == null)
{
info = new IndexMetadata(rs);
indexes.Add(info.getName().ToLower(), info);
}
foreach (DataRow row in meta.GetIndexColumns(schema, name, index).Rows)
{
info.AddColumn(GetColumnMetadata((string)row["COLUMN_NAME"]));
}
}
public void SetUp()
{
_session = MockRepository.GenerateStrictMock<HttpSessionStateBase>();
_session.Stub(s => s["Connectionstring"]).Return(Connectionstring);
_context = MockRepository.GenerateStrictMock<HttpContextBase>();
_context.Stub(c => c.Session).Return(_session);
_connectionstringBuilder = MockRepository.GenerateStub<IConnectionstringBuilder>();
_connectionstringBuilder.Expect(cb => cb.BuildConnectionString(Arg<IConnectionstringArguments>.Is.Anything)).Return(Connectionstring);
var sqlServerConnectionstringArgumentsMapper = new SqlServerConnectionstringArgumentsMapper();
_connectionstringArgumentsMapperFactory = MockRepository.GenerateStrictMock<IConnectionstringArgumentsMapperFactory>();
_connectionstringArgumentsMapperFactory.Expect(factory => factory.Make(Arg<string>.Is.Anything)).Return(sqlServerConnectionstringArgumentsMapper);
_schemaReader = MockRepository.GenerateStub<ISchemaReader>();
}
private SchemaLexer(ISchemaReader schemaReader) : base(new Tokenizer(schemaReader))
{
}
public IndexHelper(ISchemaReader schemaReader, IIndexMetadataFactory indexMetadataFactory)
{
this.schemaReader = schemaReader;
this.indexMetadataFactory = indexMetadataFactory;
}
public void InitializeContext()
{
this.extension = null;
this.reader = new Mock<ISchemaReader>().Object;
this.resource = new Mock<ISchemaResource>().Object;
}
public DatabaseSchemaExplorer(IConnectionstringBuilder connectionstringBuilder, ISchemaReader schemaReader)
{
_connectionstringBuilder = connectionstringBuilder;
_schemaReader = schemaReader;
}
private static IEnumerable <IInstalledToolkitInfo> GetInstalledToolkits(IExtensionManager extensionManager, ISchemaReader reader)
{
Guard.NotNull(() => extensionManager, extensionManager);
return(extensionManager.GetInstalledExtensions()
.Where(extension => IsToolkit(extension))
.Select(extension => TryCreateRegistration(reader, extension))
.Where(registration => registration != null));
}
public JunkConfigurationCreator(JunkCfg cfg, JunkRequest request, ISchemaReader schemaReader) {
_cfg = cfg;
_request = request;
_schemaReader = schemaReader;
}
public void Initialize()
{
var mock = new Mock<IInstalledExtension>();
mock.Setup(ext => ext.InstallPath).Returns(@"X:\");
mock.Setup(ext => ext.Content).Returns(
new[]
{
Mocks.Of<IExtensionContent>().First(c => c.ContentTypeName == InstalledToolkitInfo.PatternModelCustomExtensionName && c.RelativePath == @"Foo.patterndefinition" && c.Attributes == new Dictionary<string, string> { { SchemaResource.AssemblyFileProperty, "Test.dll" } }),
Mocks.Of<IExtensionContent>().First(c => c.ContentTypeName == "Other" && c.RelativePath == @"Documentation\Other.docx" && c.Attributes == new Dictionary<string, string> { { "IsCustomizable", bool.TrueString } }),
Mocks.Of<IExtensionContent>().First(c => c.ContentTypeName == "Other" && c.RelativePath == @"Sample.file" && c.Attributes == new Dictionary<string, string> { { "IsCustomizable", bool.TrueString } }),
});
this.extension = mock.Object;
this.reader = new Mock<ISchemaReader>().Object;
this.resource = new Mock<ISchemaResource>().Object;
this.target = new InstalledToolkitInfo(this.extension, this.reader, this.resource);
}
public static IWeaver Create(
ISchemaReader importAdapter,
IClassWriter exportAdapter) =>
new Weaver(importAdapter, exportAdapter);
private void InitColumns(ISchemaReader meta)
{
foreach (DataRow row in meta.GetColumns(schema, name).Rows)
{
AddColumn(row);
}
}
private AvroSchema(ISchemaReader <T> reader, ISchemaWriter <T> writer, ISchemaInfo schemaInfo) : base(schemaInfo)
{
Reader = reader;
Writer = writer;
}
public AbstractMultiVersionReader(ISchemaReader <T> providerSchemaReader)
{
this.providerSchemaReader = providerSchemaReader;
}
