C# SqlType类代码示例

 public FunctionInfo(ObjectName routineName, SqlType returnType, FunctionType functionType)
     : base(routineName)
 {
     ReturnType = returnType;
     FunctionType = functionType;
     AssertUnboundAtEnd();
 }

 public Table(string schema, string table, string alias, SqlType sqlType = SqlType.SqlServer)
 {
     this.SchemaName = schema;
     this.TableName = table;
     this.Alias = alias;
     this.formatModel = sqlType.BuildFormatSystemModel();
 }

 public ColumnAttribute(string name, SqlType type, int size, int scale)
 {
     this.name = name;
     this.type = type;
     this.size = size;
     this.scale = scale;
 }

        public static bool IsPrimitive(SqlType sqlType)
        {
            if (sqlType == SqlType.Numeric ||
                sqlType == SqlType.TinyInt ||
                sqlType == SqlType.SmallInt ||
                sqlType == SqlType.Integer ||
                sqlType == SqlType.BigInt ||
                sqlType == SqlType.Real ||
                sqlType == SqlType.Double ||
                sqlType == SqlType.Float ||
                sqlType == SqlType.Decimal)
                return true;

            if (sqlType == SqlType.BigInt ||
                sqlType == SqlType.Boolean)
                return true;

            if (sqlType == SqlType.Char ||
                sqlType == SqlType.VarChar ||
                sqlType == SqlType.LongVarChar ||
                sqlType == SqlType.String ||
                sqlType == SqlType.Clob)
                return true;

            if (sqlType == SqlType.Binary ||
                sqlType == SqlType.VarBinary ||
                sqlType == SqlType.LongVarBinary ||
                sqlType == SqlType.Blob)
                return true;

            return false;
        }

 public virtual TableColumn Add(string columnName, SqlType columnType, bool notNull)
 {
     CheckNotReadOnly();
     TableColumn column = new TableColumn(table, -1, columnName, columnType, notNull);
     columns.Add(column);
     return column;
 }

 public bool RunTableDdl(DirectoryInfo directory, SqlType dialect)
 {
     var tg = new DdlGeneratorFactory(dialect).AllTablesGenerator(_databaseSchema);
     tg.IncludeSchema = false;
     string txt;
     try
     {
         txt = tg.Write();
     }
     catch (Exception exception)
     {
         Message =
             @"An error occurred while creating the script.\n" + exception.Message;
         return false;
     }
     try
     {
         var path = Path.Combine(directory.FullName, "table.sql");
         File.WriteAllText(path, txt);
         Message = @"Wrote " + path;
         return true;
     }
     catch (Exception exception)
     {
         Message =
             @"An IO error occurred while writing the file.\n" + exception.Message;
     }
     return false;
 }

        public bool RunSprocs(DirectoryInfo directory, SqlType dialect, DatabaseTable table)
        {
            if (table == null)
            {
                Message = "No table";
                return false;
            }

            var gen = new DdlGeneratorFactory(dialect).ProcedureGenerator(table);
            if (gen == null)
            {
                //there is no sproc provider (SQLite)
                Message = @"There is no sproc generator";
                return false;
            }
            var path = Path.Combine(directory.FullName, table.Name + "_sprocs.sql");
            try
            {
                gen.WriteToScript(path);
                Message = @"Wrote " + path;
                return true;
            }
            catch (Exception exception)
            {
                Message =
                    @"An error occurred while creating the script.\n" + exception.Message;
            }
            return false;
        }

 public static SchemaExtendedReader Create(string connectionString, SqlType sqlType)
 {
     SchemaExtendedReader schemaReader;
     switch (sqlType)
     {
         case SqlType.Oracle:
             schemaReader = new OracleSchemaReader(connectionString, "System.Data.OracleClient");
             break;
         case SqlType.SqlServer:
             schemaReader = new SqlAzureOrSqlServerSchemaReader(connectionString, "System.Data.SqlClient");
             break;
         case SqlType.SqlServerCe:
             schemaReader = new SqlServerCeSchemaReader(connectionString, "System.Data.SqlServerCe.4.0");
             break;
         case SqlType.MySql:
             schemaReader = new MySqlSchemaReader(connectionString, "MySql.Data.MySqlClient");
             break;
         case SqlType.PostgreSql:
             schemaReader = new PostgreSqlSchemaReader(connectionString, "Npgsql");
             break;
         case SqlType.Db2:
             schemaReader = new Db2SchemaReader(connectionString, "IBM.Data.DB2");
             break;
         case SqlType.SQLite:
             schemaReader = new SchemaExtendedReader(connectionString, "System.Data.SQLite");
             break;
         default:
             throw new ArgumentOutOfRangeException("sqlType", "Not a recognized SqlType");
     }
     return schemaReader;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DatabaseSchema"/> class.
 /// </summary>
 /// <param name="connectionString">The connection string.</param>
 /// <param name="sqlType">Type of the provider</param>
 public DatabaseSchema(string connectionString, SqlType sqlType)
     :this(connectionString, null)
 {
     switch (sqlType)
     {
         case SqlType.SqlServer:
             Provider = "System.Data.SqlClient";
             break;
         case SqlType.Oracle:
             Provider = "System.Data.OracleClient";
             break;
         case SqlType.MySql:
             Provider = "MySql.Data.MySqlClient";
             break;
         case SqlType.SQLite:
             Provider = "System.Data.SQLite";
             break;
         case SqlType.SqlServerCe:
             Provider = "System.Data.SqlServerCe.4.0";
             break;
         case SqlType.PostgreSql:
             Provider = "Npgsql";
             break;
         case SqlType.Db2:
             Provider = "IBM.Data.DB2";
             break;
         default:
             throw new ArgumentOutOfRangeException("sqlType");
     }
 }

 public static string GetBuilderName(SqlType sql, string tableName)
 {
     string result = GetModel(sql, tableName) ?? tableName;
     result = result.Substring(0, 1).ToLower() + result.Substring(1);
     result += "Builder";
     return result;
 }

        public IndexCollation(SqlType type, CollationColumn[] columns, string function)
        {
            if (columns.Length == 0)
                throw new ArgumentException("Cannot create an empty collation.", "columns");

            if (columns.Length > 1) {
                if (!(type is SqlCompositeType))
                    throw new ArgumentException("Composite indexes must be represented by composite-type");

                SqlCompositeType ctype = (SqlCompositeType) type;
                if (ctype.PartCount != columns.Length)
                    throw new ArgumentException("Composite type size different to the number of columns given", "columns");
            }

            // Can't contain identical columns
            for (int i = 0; i < columns.Length; ++i) {
                for (int n = 0; n < columns.Length; ++n) {
                    if (i != n && columns[i].ColumnName.Equals(columns[n].ColumnName))
                        throw new ArgumentException("Repeat column '" + columns[i] +"' name");
                }
            }

            this.type = type;
            this.function = function;
            this.columns = (CollationColumn[]) columns.Clone();
        }

 public SqlWriterCommonTest(SqlType sqlType, DatabaseTable table, DbProviderFactory factory, string connectionString)
 {
     _connectionString = connectionString;
     _factory = factory;
     _table = table;
     _sqlType = sqlType;
 }

 /// <summary>
 /// トランザクション付きコマンドの取得
 /// </summary>
 /// <param name="dao"></param>
 /// <param name="tx"></param>
 /// <param name="serverType"></param>
 /// <returns></returns>
 public static DbCommand CommandTransaction(this IDao dao, DbTransaction tx, SqlType serverType)
 {
     switch (serverType)
     {
         case SqlType.SqlServer:
             {
                 var command = new SqlCommand();
                 command.Connection = (SqlConnection)dao.Con;
                 command.Transaction = (SqlTransaction)tx;
                 if (log.IsInfoEnabled)
                 {
                     log.Info("command type is SqlCommand.");
                 }
                 return command;
             }
         default:
             {
                 if (log.IsErrorEnabled)
                 {
                     log.Error("Don't supported command type. Type is " + Enum.GetName(typeof(SqlType), serverType));
                 }
                 return null;
             }
     }
 }

        public override DataObject CastTo(DataObject value, SqlType destType)
        {
            var bValue = ((SqlBoolean) value.Value);
            if (destType is StringType) {
                var s = Convert.ToString(bValue);
                // TODO: Provide a method in StringType to build a string specific to the type
                return new DataObject(destType, new SqlString(s));
            }
            if (destType is NumericType) {
                SqlNumber num;
                if (bValue == SqlBoolean.Null) {
                    num = SqlNumber.Null;
                } else if (bValue) {
                    num = SqlNumber.One;
                } else {
                    num = SqlNumber.Zero;
                }

                return new DataObject(destType, num);
            }
            if (destType is BinaryType) {
                var bytes = (byte[]) Convert.ChangeType(bValue, typeof (byte[]), CultureInfo.InvariantCulture);
                return new DataObject(destType, new SqlBinary(bytes));
            }
            if (destType is BooleanType)
                return value;

            return base.CastTo(value, destType);
        }

 public override bool CanCastTo(SqlType destType)
 {
     return destType is StringType ||
            destType is NumericType ||
            destType is BinaryType ||
            destType is BooleanType;
 }