private static object[] ScalarTest(string name, BigQueryDbType type, object parameterValue, string expectedValue) =>
 new object[]
 {
     name,
     new BigQueryParameter(type, parameterValue),
     ScalarParameter(type, expectedValue)
 };
        private static QueryParameter PopulateArrayParameter(QueryParameter parameter, object value, BigQueryDbType?arrayType)
        {
            if (value == null)
            {
                throw new InvalidOperationException("The value of an array parameter cannot be null");
            }
            if (!IsArrayValue(value))
            {
                throw new InvalidOperationException($"Invalid value for array parameter: {value.GetType()}");
            }
            List <object> values = ((IEnumerable)value).Cast <object>().ToList();

            if (values.Any(v => v == null))
            {
                throw new InvalidOperationException("Array parameter values cannot contain null elements");
            }
            BigQueryDbType actualArrayType = arrayType ?? s_typeMapping[GetArrayElementType(value)];

            parameter.ParameterType = new QueryParameterType
            {
                Type      = BigQueryDbType.Array.ToParameterApiType(),
                ArrayType = new QueryParameterType {
                    Type = actualArrayType.ToParameterApiType()
                }
            };
            var parameterValues = values
                                  .Select(p => new BigQueryParameter(actualArrayType, p).ToQueryParameter().ParameterValue)
                                  .ToList();

            parameter.ParameterValue = new QueryParameterValue {
                ArrayValues = parameterValues
            };
            return(parameter);
        }
 public void ChangeDbTypeTest(DbType dbType, BigQueryDbType bigQueryDbType)
 {
     var param = new BigQueryParameter(parameterName, DbType.Single) { Value = intValue };
     Assert.Equal(DbType.Single, param.DbType);
     Assert.Equal(BigQueryDbType.Float, param.BigQueryDbType);
     param.DbType = dbType;
     Assert.Equal(dbType, param.DbType);
     Assert.Equal(bigQueryDbType, param.BigQueryDbType);
 }
Example #4
0
        public BigQueryPartitionAttribute(BigQueryDbType type = BigQueryDbType.Date)
        {
            if (type != BigQueryDbType.Date && type != BigQueryDbType.Timestamp)
            {
                throw new InvalidOperationException($"Type can be only {BigQueryDbType.Date} or {BigQueryDbType.Timestamp}");
            }

            Type = type;
        }
        public void TypeInference(string name, object value, BigQueryDbType expectedType)
        {
            var parameter = new BigQueryParameter();

            parameter.Value = value;
            var queryParameter = parameter.ToQueryParameter();
            var actualType     = EnumMap <BigQueryDbType> .ToValue(queryParameter.ParameterType.Type);

            Assert.Equal(expectedType, actualType);
        }
 private static QueryParameter ScalarParameter(BigQueryDbType type, string value) =>
 new QueryParameter
 {
     ParameterType = new QueryParameterType {
         Type = type.ToParameterApiType()
     },
     ParameterValue = new QueryParameterValue {
         Value = value
     }
 };
 private static QueryParameter ScalarParameter(BigQueryDbType type, string value) =>
 new QueryParameter
 {
     ParameterType = new QueryParameterType {
         Type = EnumMap.ToApiValue(type)
     },
     ParameterValue = new QueryParameterValue {
         Value = value
     }
 };
        public static string ToParameterStringType(BigQueryDbType dbType)
        {
            var type = ToStringType(dbType);

            if (type == "BOOLEAN")
            {
                return("BOOL");
            }

            return(type);
        }
        object ChangeValueType(object value, int ordinal) {
            if(value == null)
                return null;

            BigQueryDbType bigQueryType = BigQueryTypeConverter.ToBigQueryDbType(schema.Fields[ordinal].Type);
            if(bigQueryType == BigQueryDbType.Timestamp) {
                return UnixTimeStampToDateTime(value);
            }

            return Convert.ChangeType(value, BigQueryTypeConverter.ToType(schema.Fields[ordinal].Type), CultureInfo.InvariantCulture);
        }
Example #10
0
        public void ArrayTypeInference(string name, object value, BigQueryDbType expectedArrayType)
        {
            var parameter = new BigQueryParameter();

            parameter.Value = value;
            var queryParameter = parameter.ToQueryParameter(BigQueryParameterMode.Positional);

            Assert.Equal(BigQueryDbType.Array.ToParameterApiType(), queryParameter.ParameterType.Type);
            var actualArrayType = EnumMap <BigQueryDbType> .ToValue(queryParameter.ParameterType.ArrayType.Type);

            Assert.Equal(expectedArrayType, actualArrayType);
        }
        public void ChangeBigQueryDbTypeTest(BigQueryDbType bigQueryDbType, DbType dbType)
        {
            var param = new BigQueryParameter(parameterName, DbType.Single)
            {
                Value = intValue
            };

            Assert.Equal(DbType.Single, param.DbType);
            Assert.Equal(BigQueryDbType.Float, param.BigQueryDbType);
            param.BigQueryDbType = bigQueryDbType;
            Assert.Equal(bigQueryDbType, param.BigQueryDbType);
            Assert.Equal(dbType, param.DbType);
        }
Example #12
0
        /// <summary>
        /// Creates a field with the specified details, and adds it to the schema being built.
        /// </summary>
        /// <param name="name">The name of the field. Must be a valid field name.</param>
        /// <param name="type">The type of the field. Must be a defined member within <see cref="BigQueryDbType"/>, other than <c>Struct</c> or <c>Array</c>.</param>
        /// <param name="mode">The mode of the field. Must be a defined member within <see cref="BigQueryFieldMode"/>.</param>
        /// <param name="description">The description of the field. May be null.</param>
        public void Add(string name, BigQueryDbType type, BigQueryFieldMode mode = BigQueryFieldMode.Nullable, string description = null)
        {
            ValidateFieldName(name, nameof(name));
            GaxPreconditions.CheckArgument(type != BigQueryDbType.Struct, nameof(type),
                                           $"{nameof(BigQueryDbType.Struct)} fields must be specified with their schema");
            GaxPreconditions.CheckArgument(type != BigQueryDbType.Array, nameof(type),
                                           $"{nameof(BigQueryDbType.Array)} fields must be specified with by element type with a {nameof(BigQueryFieldMode)} of {nameof(BigQueryFieldMode.Repeated)}");

            Add(new TableFieldSchema
            {
                Name        = name,
                Type        = EnumMap.ToApiValue(type, nameof(type)),
                Mode        = EnumMap.ToApiValue(mode, nameof(mode)),
                Description = description,
            });
        }
 public static Type ToType(BigQueryDbType bqDbType)
 {
     return(ToType(ToDbType(bqDbType)));
 }
 public void InferDbTypeAndBigQueryDbTypeFromValueTest(object value, DbType exceptedDbType, BigQueryDbType exceptedBQDbType)
 {
     var param = new BigQueryParameter() {Value = value};
     Assert.Equal(value, param.Value);
     Assert.Equal(exceptedDbType, param.DbType);
     Assert.Equal(exceptedBQDbType, param.BigQueryDbType);
 }
 public void DbTypeAndBigQueryDbTypeTest(DbType dbType1, BigQueryDbType bigQueryType, DbType dbType2)
 {
     Assert.Equal(bigQueryType, BigQueryTypeConverter.ToBigQueryDbType(dbType1));
     Assert.Equal(dbType2, BigQueryTypeConverter.ToDbType(bigQueryType));
 }
 public void StringConvertTest(string stringType, Type systemType, BigQueryDbType bigQueryType)
 {
     Assert.Equal(systemType, BigQueryTypeConverter.ToType(stringType));
     Assert.Equal(bigQueryType, BigQueryTypeConverter.ToBigQueryDbType(stringType));
 }
 /// <summary>
 /// Initializes a new instance of the BigQueryParameter class with the specified settings.
 /// </summary>
 /// <param name="parameterName">The name of the parameter.</param>
 /// <param name="bigQueryDbType">A BigQueryDbType enumeration value specifying the data type of the parameter.</param>
 public BigQueryParameter(string parameterName, BigQueryDbType bigQueryDbType)
     : this()
 {
     ParameterName = parameterName;
     BigQueryDbType = bigQueryDbType;
 }
 public void TypeAndBigQueryDbTypeTest(Type type1, BigQueryDbType bigQueryType, Type type2)
 {
     Assert.Equal(bigQueryType, BigQueryTypeConverter.ToBigQueryDbType(type1));
     Assert.Equal(type2, BigQueryTypeConverter.ToType(bigQueryType));
 }
 public static DbType ToDbType(BigQueryDbType bqDbType)
 {
     return(DbTypeToBigQueryDbTypePairs.FindLeftPairFor(bqDbType));
 }
 public void TypeAndBigQueryDbTypeTest(Type type1, BigQueryDbType bigQueryType, Type type2)
 {
     Assert.Equal(bigQueryType, BigQueryTypeConverter.ToBigQueryDbType(type1));
     Assert.Equal(type2, BigQueryTypeConverter.ToType(bigQueryType));
 }
 public void TimesTest(string bigQueryTypeName, Type systemType, BigQueryDbType bigQueryDbType, DbType dbType)
 {
     Assert.Equal(systemType, BigQueryTypeConverter.ToType(bigQueryTypeName));
     Assert.Equal(bigQueryDbType, BigQueryTypeConverter.ToBigQueryDbType(bigQueryTypeName));
     Assert.Equal(dbType, BigQueryTypeConverter.ToDbType(bigQueryDbType));
 }
 public void StringConvertTest(string stringType, Type systemType, BigQueryDbType bigQueryType)
 {
     Assert.Equal(systemType, BigQueryTypeConverter.ToType(stringType));
     Assert.Equal(bigQueryType, BigQueryTypeConverter.ToBigQueryDbType(stringType));
 }
 static string ToStringType(BigQueryDbType dbType)
 {
     return(StringToBigQueryDbTypePairs.FindLeftPairFor(dbType));
 }
 /// <summary>
 /// Initializes a new instance of the BigQueryParameter class with the specified settings.
 /// </summary>
 /// <param name="parameterName">The name of the parameter.</param>
 /// <param name="bigQueryDbType">A BigQueryDbType enumeration value specifying the data type of the parameter.</param>
 public BigQueryParameter(string parameterName, BigQueryDbType bigQueryDbType) : this()
 {
     ParameterName  = parameterName;
     BigQueryDbType = bigQueryDbType;
 }
 /// <summary>
 /// Constructs a parameter with no name, initial value or type.
 /// </summary>
 /// <param name="type">The initial type of the parameter.</param>
 public BigQueryParameter(BigQueryDbType type) : this(null, type, null)
 {
 }
 public void DbTypeAndBigQueryDbTypeTest(DbType dbType1, BigQueryDbType bigQueryType, DbType dbType2)
 {
     Assert.Equal(bigQueryType, BigQueryTypeConverter.ToBigQueryDbType(dbType1));
     Assert.Equal(dbType2, BigQueryTypeConverter.ToDbType(bigQueryType));
 }
Example #27
0
 internal static string ToParameterApiType(this BigQueryDbType type) => s_typeToNameMapping[type];
        public void InferDbTypeAndBigQueryDbTypeFromValueTest(object value, DbType exceptedDbType, BigQueryDbType exceptedBQDbType)
        {
            var param = new BigQueryParameter()
            {
                Value = value
            };

            Assert.Equal(value, param.Value);
            Assert.Equal(exceptedDbType, param.DbType);
            Assert.Equal(exceptedBQDbType, param.BigQueryDbType);
        }