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