Exemple #1
0
        public void CreateSimpleTableAsAdmin_NewSession()
        {
            var tableName = ObjectName.Parse("APP.test_table");
            var tableInfo = new TableInfo(tableName);

            tableInfo.AddColumn("a", PrimitiveTypes.Integer(), true);
            tableInfo.AddColumn("b", PrimitiveTypes.String());

            using (var session = CreateUserSession(AdminUserName, AdminPassword)) {
                using (var query = session.CreateQuery()) {
                    Assert.DoesNotThrow(() => query.CreateTable(tableInfo));
                    Assert.DoesNotThrow(() => query.Commit());
                }
            }

            using (var session = CreateUserSession(AdminUserName, AdminPassword)) {
                using (var query = session.CreateQuery()) {
                    bool exists = false;
                    Assert.DoesNotThrow(() => exists = query.TableExists(tableName));
                    Assert.IsTrue(exists);
                }
            }
        }
 public static SqlObject Integer(int value)
 {
     return(new SqlObject(PrimitiveTypes.Integer(), (SqlNumber)value));
 }
        private static SqlType GetSqlType(ISqlValue value)
        {
            if (value == null ||
                SqlNull.Value == value)
            {
                throw new ArgumentException();
            }

            if (value is SqlNumber)
            {
                var number = (SqlNumber)value;

                if (number.CanBeInt32)
                {
                    return(PrimitiveTypes.Integer());
                }
                if (number.CanBeInt64)
                {
                    return(PrimitiveTypes.BigInt());
                }

                if (number.Precision == SqlNumericType.FloatPrecision)
                {
                    return(new SqlNumericType(SqlTypeCode.Float, number.Precision, number.Scale));
                }
                if (number.Precision == SqlNumericType.DoublePrecision)
                {
                    return(new SqlNumericType(SqlTypeCode.Double, number.Precision, number.Scale));
                }
                if (number.Precision == SqlNumericType.DecimalPrecision)
                {
                    return(new SqlNumericType(SqlTypeCode.Decimal, number.Precision, number.Scale));
                }

                return(PrimitiveTypes.Numeric(number.Precision, number.Scale));
            }

            if (value is ISqlString)
            {
                // TODO: support the long string
                var length = ((ISqlString)value).Length;

                return(PrimitiveTypes.VarChar((int)length));
            }

            if (value is SqlBinary)
            {
                var bin = (SqlBinary)value;

                return(PrimitiveTypes.VarBinary((int)bin.Length));
            }

            if (value is SqlDateTime)
            {
                return(PrimitiveTypes.TimeStamp());
            }

            if (value is SqlBoolean)
            {
                return(PrimitiveTypes.Boolean());
            }

            if (value is SqlYearToMonth)
            {
                return(PrimitiveTypes.YearToMonth());
            }
            if (value is SqlDayToSecond)
            {
                return(PrimitiveTypes.DayToSecond());
            }

            if (value is SqlArray)
            {
                return(PrimitiveTypes.Array(((SqlArray)value).Length));
            }

            throw new NotSupportedException();
        }
        public static SqlType FromValue(object value)
        {
            if (value is SqlNumber)
            {
                var number = (SqlNumber)value;
                if (number.Scale == 0)
                {
                    if (number.Precision <= 3)
                    {
                        return(PrimitiveTypes.TinyInt());
                    }
                    if (number.Precision <= 5)
                    {
                        return(PrimitiveTypes.SmallInt());
                    }
                    if (number.Precision <= 10)
                    {
                        return(PrimitiveTypes.Integer());
                    }
                    if (number.Precision <= 19)
                    {
                        return(PrimitiveTypes.BigInt());
                    }
                }
                else
                {
                    if (number.Precision <= 8)
                    {
                        return(PrimitiveTypes.Float());
                    }
                    if (number.Precision <= 12)
                    {
                        return(PrimitiveTypes.Double());
                    }

                    return(PrimitiveTypes.Numeric(number.Precision, number.Scale));
                }
            }

            if (value is SqlBoolean)
            {
                return(PrimitiveTypes.Boolean());
            }

            if (value is bool)
            {
                return(PrimitiveTypes.Boolean());
            }

            if (value is double)
            {
                return(PrimitiveTypes.Double());
            }
            if (value is float)
            {
                return(PrimitiveTypes.Float());
            }
            if (value is int)
            {
                return(PrimitiveTypes.Integer());
            }
            if (value is long)
            {
                return(PrimitiveTypes.BigInt());
            }
            if (value is byte)
            {
                return(PrimitiveTypes.TinyInt());
            }
            if (value is short)
            {
                return(PrimitiveTypes.SmallInt());
            }

            if (value is string)
            {
                return(PrimitiveTypes.String());
            }

            throw new NotSupportedException();
        }