[TestMethod] public void ExtractFromNull()
{
// Arrange
var v = 100;
var value = DBValue.Create(v);
var mockExtractor = new Mock <IFieldExtractor>();
mockExtractor.Setup(e => e.ExpectedSource).Returns(typeof(string));
mockExtractor.Setup(e => e.FieldType).Returns(typeof(Exception));
mockExtractor.Setup(e => e.Execute(null)).Returns(null);
var mockDecomp = new Mock <IExtractionStep>();
mockDecomp.Setup(d => d.ExpectedSource).Returns(typeof(Exception));
mockDecomp.Setup(d => d.Execute(It.IsAny <int>())).Returns(new DBValue[] { value, value });
mockDecomp.Setup(d => d.Execute(null)).Returns(new DBValue[] { DBValue.NULL, DBValue.NULL });
var decomps = new IExtractionStep[] { mockDecomp.Object };
var step = new DecomposingExtractionStep(mockExtractor.Object, decomps);
string?source = null;
// Act
var values = step.Execute(source);
// Assert
values.Should().BeEquivalentTo(new DBValue[] { DBValue.NULL, DBValue.NULL });
}
public void IfThenClauseNegated()
{
// Arrange
var mockField = new Mock <IField>().Object;
var expr = new FieldExpression(mockField);
var pred = new ConstantClause(expr, ComparisonOperator.GTE, DBValue.Create(100));
var subseq = new ConstantClause(expr, ComparisonOperator.LTE, DBValue.Create(200));
var subseqNeg = new ConstantClause(expr, ComparisonOperator.GT, DBValue.Create(200));
var clause = Clause.IfThen(pred, subseq).Negation();
var mockBuilder = new Mock <IConstraintDeclBuilder>();
// Sequence
var sequence = mockBuilder.MakeSequence();
sequence.Add(builder => builder.StartClause());
sequence.Add(builder => builder.AddClause(subseqNeg.Matcher()));
sequence.Add(builder => builder.And());
sequence.Add(builder => builder.AddClause(pred.Matcher()));
sequence.Add(builder => builder.EndClause());
// Act
var fields = clause.GetDependentFields();
clause.AddDeclarationTo(mockBuilder.Object);
// Assert
fields.Should().BeEquivalentTo(new IField[] { mockField, mockField });
sequence.VerifyCompleted();
mockBuilder.VerifyNoOtherCalls();
}
[TestMethod] public void DecomposeWithMultipleSteps()
{
// Arrange
var v = 100;
var value0 = DBValue.Create(v);
var value1 = DBValue.Create(v * 10);
var mockExtractor = new Mock <IFieldExtractor>();
mockExtractor.Setup(e => e.ExpectedSource).Returns(typeof(string));
mockExtractor.Setup(e => e.FieldType).Returns(typeof(Exception));
mockExtractor.Setup(e => e.Execute(It.IsAny <string>())).Returns(v);
var mockDecomp0 = new Mock <IExtractionStep>();
mockDecomp0.Setup(d => d.ExpectedSource).Returns(typeof(Exception));
mockDecomp0.Setup(d => d.Execute(It.IsAny <int>())).Returns(new DBValue[] { value0 });
var mockDecomp1 = new Mock <IExtractionStep>();
mockDecomp1.Setup(d => d.ExpectedSource).Returns(typeof(Exception));
mockDecomp1.Setup(d => d.Execute(It.IsAny <int>())).Returns(new DBValue[] { value1, value0 });
var decomps = new IExtractionStep[] { mockDecomp0.Object, mockDecomp1.Object };
var step = new DecomposingExtractionStep(mockExtractor.Object, decomps);
var source = "Albany";
// Act
var values = step.Execute(source);
// Assert
mockExtractor.Verify(e => e.Execute(source), Times.Once);
mockDecomp0.Verify(d => d.Execute(v), Times.Once);
mockDecomp1.Verify(d => d.Execute(v), Times.Once);
values.Should().BeEquivalentTo(new DBValue[] { value0, value1, value0 });
}
[TestMethod] public void StringifyRegular()
{
// Arrange
var rawBool = true;
var rawInt = 89;
var rawFloat = -123.11106;
var rawDate = new DateTime(2016, 11, 03);
var boolValue = DBValue.Create(rawBool);
var intValue = DBValue.Create(rawInt);
var floatValue = DBValue.Create(rawFloat);
var dateValue = DBValue.Create(rawDate);
// Act
var rawBoolStr = rawBool.ToString();
var rawIntStr = rawInt.ToString();
var rawFloatStr = rawFloat.ToString();
var rawDateStr = rawDate.ToString();
var boolStr = boolValue.ToString();
var intStr = intValue.ToString();
var floatStr = floatValue.ToString();
var dateStr = dateValue.ToString();
// Assert
boolStr.Should().Be(rawBoolStr);
intStr.Should().Be(rawIntStr);
floatStr.Should().Be(rawFloatStr);
dateStr.Should().Be(rawDateStr);
}
static void test_db_tablecreate(string[] words)
{
try
{
Console.WriteLine("test db table");
using (var snap = db.UseSnapShot())
{
var writetask = db.CreateWriteTask();
{
var info = new TableInfo(
new byte[] { 0x01, 0x02, 0x03 }, //tableid 是区分表格的数据，至少长度2，太短的不允许
//下面三个参数都是提供表的信息，无所谓什么
"mytable", //tablename
"testtable0001", //tabledesc
DBValue.Type.String //tablekeytype
);
writetask.CreateTable(info);
for (var i = 0; i < 100; i++)
{
var key = ("key" + i).ToBytes_UTF8Encode();
writetask.Put(new byte[] { 0x01, 0x02, 0x03 }, key, DBValue.FromValue(DBValue.Type.UINT32, (UInt32)i));
}
db.Write(writetask);
}
}
Console.WriteLine("create table and write 100 item.");
}
catch (Exception err)
{
Console.WriteLine("error:" + err.Message);
}
}
static void test_db_tablewrite(string[] words)
{
try
{
Console.WriteLine("test db table");
using (var snap = db.UseSnapShot())
{
var writetask = db.CreateWriteTask();
{
//写100个uint32
for (var i = 0; i < 100; i++)
{
var key = ("key" + i).ToBytes_UTF8Encode();
writetask.Put(new byte[] { 0x01, 0x02, 0x03 }, key, DBValue.FromValue(DBValue.Type.UINT32, (UInt32)i));
}
//写100个字符串
for (var i = 0; i < 100; i++)
{
var key = ("skey" + i).ToBytes_UTF8Encode();
writetask.Put(new byte[] { 0x01, 0x02, 0x03 }, key, DBValue.FromValue(DBValue.Type.String, "abcdefg" + i));
}
db.Write(writetask);
}
}
}
catch (Exception err)
{
Console.WriteLine("error:" + err.Message);
}
}
public WhereClause(string column, ComparisonSymbol comparisonSymbol, DBValue value, bool and)
{
this.column = column;
this.comparisonSymbol = comparisonSymbol;
this.value = value;
this.and = and;
}
// GetKeyValue
IEnumerator GetKeyValue(Bucket bucket, string key)
{
// Get the value for the key
var getReq = bucket.Get(key);
yield return(getReq.WaitUntilDone());
if (getReq.isSuccessful)
{
// Try to deserialize the data to a string. If this does not work, use the raw data.
var encoding = getReq.GetEncoding();
if (encoding == Encoding.Json)
{
var tree = getReq.GetValue <JsonTree>();
data[key] = new DBValue {
text = tree.ToString(),
tree = tree,
encoding = encoding
};
}
else
{
data[key] = new DBValue {
text = getReq.GetValueRaw(),
tree = null,
encoding = encoding
};
}
}
else
{
Debug.LogError("Error querying value for key: " + key);
}
}
static void DBGetBlockHash(string[] words)
{
UInt64 blockid = UInt64.Parse(words[1]);
var msg = client.Post_snapshot_getblockhash(lastSnapheight.Value, blockid);
//var msg = client.Post_snapshot_getvalue(lastSnapheight.Value, protocol_Helper.systemtable_block, BitConverter.GetBytes(blockid));
var v = DBValue.FromRaw(msg.data);
lasthash = v.value;
Console.WriteLine("got hash=" + v.value.ToString_Hex());
}
public SeznamPoplatku(string login, string password, int EXT_APP_KOD)
{
XPOConnector xpc = new XPOConnector(login, password);
sesna = xpc.GetSession();
dbValue = DBValue.Instance(sesna);
this.EXT_APP_KOD = EXT_APP_KOD;
login = dbValue.DBUserName;
}
[TestMethod] public void CreateFromNull()
{
// Arrange
object?rawValue = null;
// Act
var value = DBValue.Create(rawValue);
// Assert
value.Should().Be(DBValue.NULL);
}
[TestMethod] public void StringValueFitsEnumeration()
{
// Arrange
var type = DBType.Enumeration;
var value = DBValue.Create("String");
// Act
var isInstance = value.IsInstanceOf(type);
// Assert
isInstance.Should().BeTrue();
}
[TestMethod] public void StringifyText()
{
// Arrange
var rawString = "Justin Millman";
var stringValue = DBValue.Create(rawString);
// Act
var expected = $"\"{rawString}\"";
var stringStr = stringValue.ToString();
// Assert
stringStr.Should().Be(expected);
}
[TestMethod] public void StringifyCharacter()
{
// Arrange
var rawChar = '&';
var charValue = DBValue.Create(rawChar);
// Act
var expected = $"'{rawChar}'";
var charStr = charValue.ToString();
// Assert
charStr.Should().Be(expected);
}
[TestMethod] public void CreateFromDoubleIndirectly()
{
// Arrange
var rawValue = -317.445;
var expectedType = DBType.Double;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromLongDirectly()
{
// Arrange
var rawValue = 499182371L;
var expectedType = DBType.Int64;
// Act
var value = new DBValue(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromUShortDirectly()
{
// Arrange
var rawValue = (ushort)102;
var expectedType = DBType.UInt16;
// Act
var value = new DBValue(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromBoolInirectly()
{
// Arrange
var rawValue = false;
var expectedType = DBType.Boolean;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromArrayFails()
{
// Arrange
var rawValue = new double[] { 1.1, 2.2, 3.3, 4.4, 5.5 };
// Act
Func <DBValue> action = () => DBValue.Create(rawValue);
// Assert
action.Should().ThrowExactly <ArgumentException>()
.WithAnyMessage()
.And
.ParamName.Should().NotBeNullOrEmpty();
}
[TestMethod] public void CreateFromDecimalIndirectly()
{
// Arrange
var rawValue = (decimal)86.77;
var expectedType = DBType.Decimal;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromCharDirectly()
{
// Arrange
var rawValue = '%';
var expectedType = DBType.Character;
// Act
var value = new DBValue(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromFloatIndirectly()
{
// Arrange
var rawValue = -99.000102f;
var expectedType = DBType.Single;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromULongIndirectly()
{
// Arrange
var rawValue = 111110108ul;
var expectedType = DBType.UInt64;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromStringIndirectly()
{
// Arrange
var rawValue = "Kvasir";
var expectedType = DBType.Text;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromGuidIndirectly()
{
// Arrange
var rawValue = new Guid(0, 1, 1, new byte[] { 2, 3, 5, 8, 13, 21, 34, 55 });
var expectedType = DBType.Guid;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromDateTimeIndirectly()
{
// Arrange
var rawValue = new DateTime(1996, 02, 29);
var expectedType = DBType.DateTime;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromEnumerationFails()
{
// Arrange
var rawValue = EnvironmentVariableTarget.Machine;
// Act
Func <DBValue> action = () => DBValue.Create(rawValue);
// Assert
action.Should().ThrowExactly <ArgumentException>()
.WithAnyMessage()
.And
.ParamName.Should().NotBeNullOrEmpty();
}
[TestMethod] public void WeakEquality()
{
// Arrange
var now = new DBValue(DateTime.Now);
var nonDbValue = now.Datum;
object?nll = null;
// Act
var areNotEqual = FullCheck.ExpectNotEqual(now, nonDbValue);
var nullAreNotEqual = FullCheck.ExpectNotEqual(now, nll);
// Assert
areNotEqual.Should().NotHaveValue();
nullAreNotEqual.Should().NotHaveValue();
}
// EditWindow
void EditWindow(int id)
{
//GUILayout.FlexibleSpace();
editValue.text = GUILayout.TextArea(editValue.text);
GUILayout.FlexibleSpace();
if (GUILayout.Button("Update"))
{
StartCoroutine(SetKeyValue(currentBucket, editKey, editValue));
}
if (GUILayout.Button("Cancel"))
{
editKey = "";
editValue = null;
}
}
[TestMethod] public void Construct()
{
// Arrange
var name = new FieldName("Population");
var dbType = DBType.Int32;
var nullability = IsNullable.No;
var defaultValue = Option.Some(DBValue.Create(100));
// Act
var field = new BasicField(name, dbType, nullability, defaultValue);
// Assert
field.Name.Should <FieldName>().Be(name);
field.DataType.Should().Be(dbType);
field.Nullability.Should().Be(nullability);
field.DefaultValue.Should().Be(defaultValue);
}
public void UpdateCreate(DBValue dbval, Connector connector)
{
var connection = connector.Connection;
if (connection.State != ConnectionState.Open)
connection.Open();
if (_valuesByQualifier.ContainsKey(dbval.Qualifier)) {
var command = new SqlCommand(String.Format(
"update {0} set {1} = @content where {2} = @part and {3} = @locale and {4} = @key",
_table, ContentColumn, PartIdColumn, LocaleIdColumn, KeyColumn
), connection
);
command.Parameters.Add(new SqlParameter("content", SqlDbType.VarChar) { Value = dbval.Content });
command.Parameters.Add(new SqlParameter("part", SqlDbType.BigInt) { Value = dbval.Qualifier.PartId });
command.Parameters.Add(new SqlParameter("locale", SqlDbType.Int) { Value = dbval.Qualifier.LocaleId });
command.Parameters.Add(new SqlParameter("key", SqlDbType.VarChar) { Value = dbval.Qualifier.Key });
if (command.ExecuteNonQuery() > 0)
_valuesByQualifier[dbval.Qualifier] = dbval;
}
else {
var command = new SqlCommand(String.Format(
"insert into {0}({1}, {2}, {3}, {4}) values(@content, @part, @locale, @key)",
_table, ContentColumn, PartIdColumn, LocaleIdColumn, KeyColumn
), connection
);
command.Parameters.Add(new SqlParameter("content", SqlDbType.VarChar) { Value = dbval.Content });
command.Parameters.Add(new SqlParameter("part", SqlDbType.BigInt) { Value = dbval.Qualifier.PartId });
command.Parameters.Add(new SqlParameter("locale", SqlDbType.Int) { Value = dbval.Qualifier.LocaleId });
command.Parameters.Add(new SqlParameter("key", SqlDbType.VarChar) { Value = dbval.Qualifier.Key });
if(command.ExecuteNonQuery() > 0)
_valuesByQualifier.Add(dbval.Qualifier, dbval);
}
}
private void ReloadValues(SqlConnection connection)
{
_valuesByQualifier.Clear();
var command = new SqlCommand(String.Format(
"select {0}, {1}, {2}, {3} from {4}",
PartIdColumn, LocaleIdColumn, KeyColumn, ContentColumn, _table
), connection);
using(var result = command.ExecuteReader()){
if (!result.HasRows) return;
while (result.Read()) {
var value = new DBValue(result.GetInt64(0), result.GetInt32(1), result.GetString(2), result.GetString(3));
_valuesByQualifier.Add(value.Qualifier, value);
}
}
}
public DBValue Insert(DBValue value, Connector connector)
{
var connection = connector.Connection;
if (connection.State != ConnectionState.Open)
connection.Open();
_valuesByQualifier.Add(value.Qualifier, value);
var command = new SqlCommand(String.Format(
"insert into {0}({1}, {2}, {3}, {4}) values(@part, @locale, @key, @content)",
_table, PartIdColumn, LocaleIdColumn, KeyColumn, ContentColumn
), connection
);
command.Parameters.Add(new SqlParameter("part", SqlDbType.BigInt) { Value = value.Qualifier.PartId });
command.Parameters.Add(new SqlParameter("locale", SqlDbType.Int) { Value = value.Qualifier.LocaleId });
command.Parameters.Add(new SqlParameter("key", SqlDbType.VarChar) { Value = value.Qualifier.Key });
command.Parameters.Add(new SqlParameter("content", SqlDbType.VarChar) { Value = value.Content });
command.ExecuteNonQuery();
return value;
}
