public static DataConnection CreateDataConnection( string connectionString, SqlServerVersion version = SqlServerVersion.v2008, SqlServerProvider provider = SqlServerProvider.SystemDataSqlClient) { return(new DataConnection(GetDataProvider(version, provider), connectionString)); }
private static DataConnection CreateDataConnection(string connectionString, SqlServerVersion sqlServerVersion) { var sqlServerDataProvider = (SqlServerDataProvider)SqlServerTools.GetDataProvider(sqlServerVersion, SqlServerProvider.MicrosoftDataSqlClient); DatabaseContext.CreateMappings(sqlServerDataProvider.MappingSchema); return(new DataConnection(sqlServerDataProvider, new SqlConnection(connectionString))); }
public static void Script(string[] target, Database db , string output, bool progress, SqlServerVersion sql_version , bool do_version)//.Version100) { if (null == db) { throw new ScripterException("Invalid Database"); } _do_version = do_version; Scripter scripter = new Scripter(db.Parent); ScriptingOptions op = new ScriptingOptions { AllowSystemObjects = false , WithDependencies = false , ClusteredIndexes = true , Indexes = true , DriAllConstraints = true //, //, DriAll = true , TargetServerVersion = sql_version }; System.Console.WriteLine("Target Version {0}", op.TargetServerVersion); scripter.Options = op; Script(target, db, scripter, output, progress); }
public static DataConnection CreateDataConnection( IDbTransaction transaction, SqlServerVersion version = SqlServerVersion.v2008, SqlServerProvider provider = SqlServerProvider.SystemDataSqlClient) { return(new DataConnection(GetDataProvider(version, provider), transaction)); }
public static bool SupportsVersion(TSqlPlatforms platform, SqlServerVersion version) { switch (version) { case SqlServerVersion.Sql90: return((platform & TSqlPlatforms.Sql90) == TSqlPlatforms.Sql90); case SqlServerVersion.Sql100: return((platform & TSqlPlatforms.Sql100) == TSqlPlatforms.Sql100); case SqlServerVersion.Sql110: return((platform & TSqlPlatforms.Sql110) == TSqlPlatforms.Sql110); case SqlServerVersion.Sql120: return((platform & TSqlPlatforms.Sql120) == TSqlPlatforms.Sql120); case SqlServerVersion.Sql130: return((platform & TSqlPlatforms.Sql130) == TSqlPlatforms.Sql130); case SqlServerVersion.Sql140: return((platform & TSqlPlatforms.Sql140) == TSqlPlatforms.Sql140); case SqlServerVersion.SqlAzure: return((platform & TSqlPlatforms.SqlAzure) == TSqlPlatforms.SqlAzure); default: return(false); } }
protected virtual IDataProvider CreateSqlServerProvider(SqlServerVersion version, string connectionString) { if (!string.IsNullOrEmpty(connectionString)) { return(DataConnection.GetDataProvider("System.Data.SqlClient", connectionString)); } string providerName; switch (version) { case SqlServerVersion.v2000: providerName = ProviderName.SqlServer2000; break; case SqlServerVersion.v2005: providerName = ProviderName.SqlServer2005; break; case SqlServerVersion.v2008: providerName = ProviderName.SqlServer2008; break; case SqlServerVersion.v2012: providerName = ProviderName.SqlServer2012; break; default: throw new ArgumentOutOfRangeException(); } return(new SqlServerDataProvider(providerName, version)); }
/// <summary> /// Creates an <see cref="IDataProvider" /> that uses Microsoft.Data.SqlClient internally. /// </summary> /// <param name="sqlServerVersion">The SQL Server version of the target database (optional). Defaults to <see cref="SqlServerVersion.v2017" />.</param> /// <param name="createMappings"> /// The delegate that manipulates the mapping schema of the data provider (optional). Alternatively, you could use the Linq2Db attributes to configure /// your model classes, but we strongly recommend that you use the Linq2Db <see cref="FluentMappingBuilder" /> to specify how model classes are mapped. /// </param> public static IDataProvider CreateSqlServerDataProvider(SqlServerVersion sqlServerVersion = SqlServerVersion.v2017, Action <MappingSchema>?createMappings = null) { var dataProvider = SqlServerTools.GetDataProvider(sqlServerVersion, SqlServerProvider.MicrosoftDataSqlClient); createMappings?.Invoke(dataProvider.MappingSchema); return(dataProvider); }
public SqlConnector(string connectionString, Schema schema, DynamicQueryManager dqm, SqlServerVersion version) : base(schema, dqm) { this.connectionString = connectionString; this.ParameterBuilder = new SqlParameterBuilder(); this.Version = version; if (version >= SqlServerVersion.SqlServer2008 && schema != null) { var s = schema.Settings; if (!s.TypeValues.ContainsKey(typeof(TimeSpan))) { schema.Settings.TypeValues.Add(typeof(TimeSpan), SqlDbType.Time); } if (!s.UdtSqlName.ContainsKey(typeof(SqlHierarchyId))) { s.UdtSqlName.Add(typeof(SqlHierarchyId), "HierarchyId"); } if (!s.UdtSqlName.ContainsKey(typeof(SqlGeography))) { s.UdtSqlName.Add(typeof(SqlGeography), "Geography"); } if (!s.UdtSqlName.ContainsKey(typeof(SqlGeometry))) { s.UdtSqlName.Add(typeof(SqlGeometry), "Geometry"); } } }
public RuleTest(IList <Tuple <string, string> > testScripts, TSqlModelOptions databaseOptions, SqlServerVersion sqlVersion) { _trash = new DisposableList(); TestScripts = testScripts; DatabaseOptions = databaseOptions ?? new TSqlModelOptions(); SqlVersion = sqlVersion; }
public static TSqlParser BuildNew(SqlServerVersion version, bool quoted) { switch (version) { case SqlServerVersion.Sql90: return(new TSql90Parser(quoted)); case SqlServerVersion.Sql100: return(new TSql100Parser(quoted)); case SqlServerVersion.Sql110: return(new TSql110Parser(quoted)); case SqlServerVersion.Sql120: return(new TSql120Parser(quoted)); case SqlServerVersion.Sql130: return(new TSql130Parser(quoted)); case SqlServerVersion.Sql140: return(new TSql130Parser(quoted)); case SqlServerVersion.Sql150: return(new TSql130Parser(quoted)); default: throw new ArgumentOutOfRangeException(nameof(version), version, null); } }
public static SqlServerVersion[] GetSqlServerVersions() { var values = Enum.GetValues(typeof(SqlServerVersion)); SqlServerVersion[] array = new SqlServerVersion[values.Length]; values.CopyTo(array, 0); return(array); }
public SqlServerDataProvider(string name, SqlServerVersion version) : base(name, (MappingSchema)null) { Version = version; if (version == SqlServerVersion.v2000) { SqlProviderFlags.AcceptsTakeAsParameter = false; SqlProviderFlags.IsSkipSupported = false; SqlProviderFlags.IsCountSubQuerySupported = false; } else { SqlProviderFlags.IsApplyJoinSupported = true; SqlProviderFlags.TakeHintsSupported = TakeHints.Percent | TakeHints.WithTies; SqlProviderFlags.IsCommonTableExpressionsSupported = version >= SqlServerVersion.v2008; } SetCharField("char", (r, i) => r.GetString(i).TrimEnd(' ')); SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd(' ')); SetCharFieldToType <char>("char", (r, i) => DataTools.GetChar(r, i)); SetCharFieldToType <char>("nchar", (r, i) => DataTools.GetChar(r, i)); if (!Configuration.AvoidSpecificDataProviderAPI) { SetProviderField <SqlDataReader, SqlBinary, SqlBinary>((r, i) => r.GetSqlBinary(i)); SetProviderField <SqlDataReader, SqlBoolean, SqlBoolean>((r, i) => r.GetSqlBoolean(i)); SetProviderField <SqlDataReader, SqlByte, SqlByte>((r, i) => r.GetSqlByte(i)); SetProviderField <SqlDataReader, SqlDateTime, SqlDateTime>((r, i) => r.GetSqlDateTime(i)); SetProviderField <SqlDataReader, SqlDecimal, SqlDecimal>((r, i) => r.GetSqlDecimal(i)); SetProviderField <SqlDataReader, SqlDouble, SqlDouble>((r, i) => r.GetSqlDouble(i)); SetProviderField <SqlDataReader, SqlGuid, SqlGuid>((r, i) => r.GetSqlGuid(i)); SetProviderField <SqlDataReader, SqlInt16, SqlInt16>((r, i) => r.GetSqlInt16(i)); SetProviderField <SqlDataReader, SqlInt32, SqlInt32>((r, i) => r.GetSqlInt32(i)); SetProviderField <SqlDataReader, SqlInt64, SqlInt64>((r, i) => r.GetSqlInt64(i)); SetProviderField <SqlDataReader, SqlMoney, SqlMoney>((r, i) => r.GetSqlMoney(i)); SetProviderField <SqlDataReader, SqlSingle, SqlSingle>((r, i) => r.GetSqlSingle(i)); SetProviderField <SqlDataReader, SqlString, SqlString>((r, i) => r.GetSqlString(i)); SetProviderField <SqlDataReader, SqlXml, SqlXml>((r, i) => r.GetSqlXml(i)); SetProviderField <SqlDataReader, DateTimeOffset>((r, i) => r.GetDateTimeOffset(i)); SetProviderField <SqlDataReader, TimeSpan> ((r, i) => r.GetTimeSpan(i)); } else { SetProviderField <IDataReader, SqlString, SqlString>((r, i) => r.GetString(i)); } _sqlServer2000SqlOptimizer = new SqlServer2000SqlOptimizer(SqlProviderFlags); _sqlServer2005SqlOptimizer = new SqlServer2005SqlOptimizer(SqlProviderFlags); _sqlServer2008SqlOptimizer = new SqlServerSqlOptimizer(SqlProviderFlags); _sqlServer2012SqlOptimizer = new SqlServer2012SqlOptimizer(SqlProviderFlags); SetField <IDataReader, decimal>((r, i) => r.GetDecimal(i)); SetField <IDataReader, decimal>("money", (r, i) => SqlServerTools.DataReaderGetMoney(r, i)); SetField <IDataReader, decimal>("smallmoney", (r, i) => SqlServerTools.DataReaderGetMoney(r, i)); SetField <IDataReader, decimal>("decimal", (r, i) => SqlServerTools.DataReaderGetDecimal(r, i)); }
public DacCreator(string dacpacPath, List <Reference> references, SqlServerVersion version, TSqlModelOptions sqlModelOptions, string preDeploy, string postDeploy) { _outputPath = dacpacPath; _references = references; _version = version; _options = sqlModelOptions; _preDeployScript = preDeploy; _postDeployScript = postDeploy; }
public static MappingSchema Get(SqlServerVersion version) { return(version switch { SqlServerVersion.v2000 => SqlServer2000MappingSchema, SqlServerVersion.v2005 => SqlServer2005MappingSchema, SqlServerVersion.v2012 => SqlServer2012MappingSchema, SqlServerVersion.v2017 => SqlServer2017MappingSchema, _ => SqlServer2008MappingSchema, });
public ModelWrapper(SqlServerVersion version, string directory, string refactorLog, string preScript, string postScript, List <DacReference> ssdtReferences) { _version = version; _directory = directory; _refactorLog = refactorLog; _preScript = preScript; _postScript = postScript; _model = GetModel(); _parser = GetParser(); ModelMessages = FillModel(); }
public ModelWrapper(SqlServerVersion version, string directory, string refactorLog, string preScript, string postScript) { _version = version; _directory = directory; _refactorLog = refactorLog; _preScript = preScript; _postScript = postScript; _model = GetModel(); _parser = GetParser(); FillModel(); }
public DacCreator(Args args) { _outputPath = args.DacpacPath; _sourceFolder = args.SourcePath; _references = args.References; _version = args.SqlServerVersion; _options = args.SqlModelOptions; _preDeployScript = args.PreCompareScript; _postDeployScript = args.PostCompareScript; if(args.FixDeployScripts) ScriptFixer = new DdlScriptParser(_version); }
public static MappingSchema Get(SqlServerVersion version) { return(version switch { SqlServerVersion.v2005 => new SqlServerMappingSchema.SqlServer2005MappingSchema(), SqlServerVersion.v2012 => new SqlServerMappingSchema.SqlServer2012MappingSchema(), SqlServerVersion.v2014 => new SqlServerMappingSchema.SqlServer2014MappingSchema(), SqlServerVersion.v2016 => new SqlServerMappingSchema.SqlServer2016MappingSchema(), SqlServerVersion.v2017 => new SqlServerMappingSchema.SqlServer2017MappingSchema(), SqlServerVersion.v2019 => new SqlServerMappingSchema.SqlServer2019MappingSchema(), _ => new SqlServerMappingSchema.SqlServer2008MappingSchema(), });
public static IDataProvider GetDataProvider(SqlServerVersion version = SqlServerVersion.v2008) { switch (version) { case SqlServerVersion.v2000: return(_sqlServerDataProvider2000); case SqlServerVersion.v2005: return(_sqlServerDataProvider2005); case SqlServerVersion.v2012: return(_sqlServerDataProvider2012); } return(_sqlServerDataProvider2008); }
public static DataConnection CreateDataConnection(IDbConnection connection, SqlServerVersion version = SqlServerVersion.v2008) { switch (version) { case SqlServerVersion.v2000: return(new DataConnection(_sqlServerDataProvider2000, connection)); case SqlServerVersion.v2005: return(new DataConnection(_sqlServerDataProvider2005, connection)); case SqlServerVersion.v2012: return(new DataConnection(_sqlServerDataProvider2012, connection)); } return(new DataConnection(_sqlServerDataProvider2008, connection)); }
public static IServiceCollection AddDatabaseContext(this IServiceCollection services, string connectionString, SqlServerVersion sqlServerVersion = SqlServerVersion.v2017) { var sqlServerDataProvider = (SqlServerDataProvider)SqlServerTools.GetDataProvider(sqlServerVersion, SqlServerProvider.MicrosoftDataSqlClient); CreateMappings(sqlServerDataProvider.MappingSchema); return(services.AddSingleton(sqlServerDataProvider) .AddTransient(c => new DataConnection(c.GetRequiredService <SqlServerDataProvider>(), new SqlConnection(connectionString), true)) .AddSingleton <Func <DataConnection> >(c => c.GetRequiredService <DataConnection>)); }
/// <summary> /// 重新整理SelectCommand。 /// </summary> /// <param name="selectCommand"></param> /// <param name="sql"></param> public void FormatSelectCommand(ref SqlCommand selectCommand) { if (selectCommand == null) { return; } if (string.IsNullOrEmpty(selectCommand.CommandText)) { selectCommand.CommandText = string.Empty; } bool[] pagingArgsFlag = new bool[] { false, false, false }; foreach (SqlParameter p in selectCommand.Parameters) { if (p.Value == null) { p.Value = DBNull.Value; } if ("@PageIndex".Equals(p.ParameterName)) { pagingArgsFlag[0] = true; } if ("@DataCount".Equals(p.ParameterName)) { pagingArgsFlag[1] = true; } if ("@SortBy".Equals(p.ParameterName)) { pagingArgsFlag[2] = true; } } bool pagingFlag = pagingArgsFlag[0] && pagingArgsFlag[1] && pagingArgsFlag[2]; SqlServerVersion sv = SqlServerVersion.SqlServer2005; if (selectCommand.CommandType == CommandType.Text && selectCommand.Connection != null && pagingFlag) { if (SqlServerSet.Instance.FXTConnectionString.Equals(selectCommand.Connection.ConnectionString)) { sv = SqlServerSet.Instance.FXTDataBaseVersion; } else if (SqlServerSet.Instance.TestConnectionString.Equals(selectCommand.Connection.ConnectionString)) { sv = SqlServerSet.Instance.TestDataBaseVersion; } selectCommand.CommandText = this.PagingDataView(selectCommand.CommandText , sv , Convert.ToInt32(selectCommand.Parameters["@PageIndex"].Value.ToString()) , Convert.ToInt32(selectCommand.Parameters["@DataCount"].Value.ToString()) , selectCommand.Parameters["@SortBy"].Value.ToString() ); } }
/// <summary> /// 对Sql语句进行分页处理。 /// </summary> /// <param name="dataView">待处理的Sql语句。</param> /// <param name="sqlServerVersion">SqlServer版本。</param> /// <param name="pageIndex">分页页码。</param> /// <param name="dataCount">每页显示数据数量。</param> /// <param name="sortBy">排序规则。</param> /// <param name="viewName">生成子视图名称。</param> /// <param name="rowIndexName">生成行标记序列名称。</param> /// <returns>处理后的分页语句。</returns> public string PagingDataView(string dataView, SqlServerVersion sqlServerVersion, int pageIndex, int dataCount, string sortBy, string viewName, string rowIndexName) { if (string.IsNullOrEmpty(dataView)) { return(dataView); } if (pageIndex < 1) { pageIndex = 1; } if (dataCount < 1) { dataCount = 1; } if (string.IsNullOrEmpty(viewName)) { viewName = string.Format("View_{0}", Guid.NewGuid().ToString().Replace("-", string.Empty)); } if (string.IsNullOrEmpty(rowIndexName)) { rowIndexName = string.Format("RowIndex_{0}", Guid.NewGuid().ToString().Replace("-", string.Empty)); } switch (sqlServerVersion) { case SqlServerVersion.SqlServer2000: { return(string.Format("select top {3} * from ({0}) as {1}_A where id not in (select top {4} id from ({0}) as {1}_B order by {2}) order by {2};select Count(*) as Amount from ({0}) as {1}_C" , dataView , viewName , sortBy , dataCount , ((pageIndex - 1) * dataCount) )); } case SqlServerVersion.SqlServer2005: { return(string.Format("select * from (select Row_Number() over(order by {3}) as {2},* from ({0}) as {1}_A) as {1}_B where {2} between {4} and {5};select Count(*) as Amount from ({0}) as {1}_C" , dataView , viewName , rowIndexName , sortBy , ((pageIndex - 1) * dataCount + 1) , (pageIndex * dataCount) )); } default: goto case SqlServerVersion.SqlServer2005; } }
public static IDataProvider GetDataProvider( SqlServerVersion version = SqlServerVersion.v2008, SqlServerProvider provider = SqlServerProvider.SystemDataSqlClient) { return(provider switch { SqlServerProvider.SystemDataSqlClient => version switch { SqlServerVersion.v2000 => _sqlServerDataProvider2000sdc.Value, SqlServerVersion.v2005 => _sqlServerDataProvider2005sdc.Value, SqlServerVersion.v2012 => _sqlServerDataProvider2012sdc.Value, SqlServerVersion.v2017 => _sqlServerDataProvider2017sdc.Value, _ => _sqlServerDataProvider2008sdc.Value, },
public DacCreator(Args args) { _outputPath = args.DacpacPath; _sourceFolder = args.SourcePath; _references = args.References; _version = args.SqlServerVersion; _options = args.SqlModelOptions; _preDeployScript = args.PreCompareScript; _postDeployScript = args.PostCompareScript; if (args.FixDeployScripts) { ScriptFixer = new DdlScriptParser(_version); } }
public SqlServerDataProvider(string name, SqlServerVersion version) : base(name, null) { Version = version; if (version == SqlServerVersion.v2000) { SqlProviderFlags.AcceptsTakeAsParameter = false; SqlProviderFlags.IsSkipSupported = false; SqlProviderFlags.IsCountSubQuerySupported = false; } else { SqlProviderFlags.IsApplyJoinSupported = true; } SetCharField("char", (r, i) => r.GetString(i).TrimEnd()); SetCharField("nchar", (r, i) => r.GetString(i).TrimEnd()); if (!Configuration.AvoidSpecificDataProviderAPI) { SetProviderField <SqlDataReader, SqlBinary, SqlBinary>((r, i) => r.GetSqlBinary(i)); SetProviderField <SqlDataReader, SqlBoolean, SqlBoolean>((r, i) => r.GetSqlBoolean(i)); SetProviderField <SqlDataReader, SqlByte, SqlByte>((r, i) => r.GetSqlByte(i)); SetProviderField <SqlDataReader, SqlDateTime, SqlDateTime>((r, i) => r.GetSqlDateTime(i)); SetProviderField <SqlDataReader, SqlDecimal, SqlDecimal>((r, i) => r.GetSqlDecimal(i)); SetProviderField <SqlDataReader, SqlDouble, SqlDouble>((r, i) => r.GetSqlDouble(i)); SetProviderField <SqlDataReader, SqlGuid, SqlGuid>((r, i) => r.GetSqlGuid(i)); SetProviderField <SqlDataReader, SqlInt16, SqlInt16>((r, i) => r.GetSqlInt16(i)); SetProviderField <SqlDataReader, SqlInt32, SqlInt32>((r, i) => r.GetSqlInt32(i)); SetProviderField <SqlDataReader, SqlInt64, SqlInt64>((r, i) => r.GetSqlInt64(i)); SetProviderField <SqlDataReader, SqlMoney, SqlMoney>((r, i) => r.GetSqlMoney(i)); SetProviderField <SqlDataReader, SqlSingle, SqlSingle>((r, i) => r.GetSqlSingle(i)); SetProviderField <SqlDataReader, SqlString, SqlString>((r, i) => r.GetSqlString(i)); SetProviderField <SqlDataReader, SqlXml, SqlXml>((r, i) => r.GetSqlXml(i)); SetProviderField <SqlDataReader, DateTimeOffset>((r, i) => r.GetDateTimeOffset(i)); SetProviderField <SqlDataReader, TimeSpan> ((r, i) => r.GetTimeSpan(i)); } else { SetProviderField <IDataReader, SqlString, SqlString>((r, i) => r.GetString(i)); } _sqlOptimizer = new SqlServerSqlOptimizer(SqlProviderFlags); _sqlServer2000SqlOptimizer = new SqlServer2000SqlOptimizer(SqlProviderFlags); _sqlServer2005SqlOptimizer = new SqlServer2005SqlOptimizer(SqlProviderFlags); }
public static MappingSchema Get(SqlServerVersion version) { switch (version) { case SqlServerVersion.v2000: return(SqlServer2000MappingSchema); case SqlServerVersion.v2005: return(SqlServer2005MappingSchema); default: case SqlServerVersion.v2008: return(SqlServer2008MappingSchema); case SqlServerVersion.v2012: return(SqlServer2012MappingSchema); case SqlServerVersion.v2017: return(SqlServer2017MappingSchema); } }
public SqlConnector(string connectionString, Schema schema, SqlServerVersion version) : base(schema) { this.connectionString = connectionString; this.ParameterBuilder = new SqlParameterBuilder(); this.Version = version; if (version >= SqlServerVersion.SqlServer2008 && schema != null) { var s = schema.Settings; if (!s.TypeValues.ContainsKey(typeof(TimeSpan))) { schema.Settings.TypeValues.Add(typeof(TimeSpan), SqlDbType.Time); } } }
private static int BuildDacpac(string name, string version, FileInfo output, SqlServerVersion sqlServerVersion, FileInfo[] input, FileInfo[] reference, string[] property) { // Set metadata for the package using var packageBuilder = new PackageBuilder(); packageBuilder.SetMetadata(name, version); // Set properties on the model (if defined) if (property != null) { foreach (var propertyValue in property) { string[] keyValuePair = propertyValue.Split('=', 2); packageBuilder.SetProperty(keyValuePair[0], keyValuePair[1]); } } // Build the empty model for te targetted SQL Server version packageBuilder.UsingVersion(sqlServerVersion); // Add references to the model if (reference != null) { foreach (var referenceFile in reference) { packageBuilder.AddReference(referenceFile); } } // Add input files if (input != null) { foreach (var inputFile in input) { packageBuilder.AddInputFile(inputFile); } } // Validate the model if (!packageBuilder.ValidateModel()) { return(1); } // Save the package to disk packageBuilder.SaveToDisk(output); return(0); }
/// <summary> /// Creates a new baselined test. The input files and baseline file will be loaded from /// the /// </summary> public BaselinedRuleTest( TestContext testContext, string testName, TSqlModelOptions databaseOptions, SqlServerVersion sqlVersion) : base(new List<Tuple<string, string>>(), databaseOptions, sqlVersion) { ScriptsFolder = GetScriptsFolder(testName); Assert.IsTrue(Directory.Exists(ScriptsFolder), "Expected the test folder '{0}' to exist", ScriptsFolder); string outputDir = testContext.TestResultsDirectory; string outputFilename = String.Format("{0}-{1}.txt", testName, Output); OutputFilePath = Path.Combine(outputDir, testName, outputFilename); string baselineFilename = String.Format("{0}-{1}.txt", testName, Baseline); BaselineFilePath = Path.Combine(ScriptsFolder, baselineFilename); }
/// <summary> /// Creates a new baselined test. The input files and baseline file will be loaded from /// the /// </summary> public BaselinedRuleTest( TestContext testContext, string testName, TSqlModelOptions databaseOptions, SqlServerVersion sqlVersion) : base(new List <Tuple <string, string> >(), databaseOptions, sqlVersion) { ScriptsFolder = GetScriptsFolder(testName); Assert.IsTrue(Directory.Exists(ScriptsFolder), "Expected the test folder '{0}' to exist", ScriptsFolder); string outputDir = testContext.TestResultsDirectory; string outputFilename = String.Format("{0}-{1}.txt", testName, Output); OutputFilePath = Path.Combine(outputDir, testName, outputFilename); string baselineFilename = String.Format("{0}-{1}.txt", testName, Baseline); BaselineFilePath = Path.Combine(ScriptsFolder, baselineFilename); }
private static void WriteInterfaceDeclaration(FormattedTextWriter writer, SqlServerVersion version, ModelTypeClass type, string interfaceName, Element element) { writer.WriteLine(); writer.WriteLine($"public interface {interfaceName} : {DacUtilities.BaseModelInterfaceFullName}"); using (writer.StartBlock()) { foreach (ModelPropertyClass property in GetProperties(type)) { if (!DacUtilities.SupportsVersion(property.SupportedPlatforms, version)) { continue; } bool useGenericGetter; string typeName = GetPropertyTypeName(property.DataType, out useGenericGetter); string propertyName = GetPropertyName(property, element); writer.WriteLine(); writer.WriteLine($"{typeName} {propertyName} {{ get; }}"); } } }
public SqlConnector(string connectionString, Schema schema, DynamicQueryManager dqm, SqlServerVersion version) : base(schema, dqm) { this.connectionString = connectionString; this.ParameterBuilder = new SqlParameterBuilder(); this.Version = version; if (version >= SqlServerVersion.SqlServer2008 && schema != null) { var s = schema.Settings; if (!s.TypeValues.ContainsKey(typeof(TimeSpan))) schema.Settings.TypeValues.Add(typeof(TimeSpan), SqlDbType.Time); if (!s.UdtSqlName.ContainsKey(typeof(SqlHierarchyId))) s.UdtSqlName.Add(typeof(SqlHierarchyId), "HierarchyId"); if (!s.UdtSqlName.ContainsKey(typeof(SqlGeography))) s.UdtSqlName.Add(typeof(SqlGeography), "Geography"); if (!s.UdtSqlName.ContainsKey(typeof(SqlGeometry))) s.UdtSqlName.Add(typeof(SqlGeometry), "Geometry"); } }
protected internal SqlServerVersionNotSupported(SqlServerVersion sqlVersion) : base($"SQL Server {sqlVersion.GetHashCode()} is not supported from SqlTableDependency.") { }
public DdlScriptParser(SqlServerVersion version) { _version = version; }