Ejemplo n.º 1
0
        public override object VisitScientific([NotNull] MiniSQLParser.ScientificContext context)
        {
            AtomValue value = new AtomValue();

            if (context.INT_NUMBER() != null)
            {
                value.Type         = AttributeTypes.Int;
                value.IntegerValue = int.Parse(context.INT_NUMBER().GetText());
            }
            else if (context.DECIMAL_NUMBER() != null)
            {
                value.Type       = AttributeTypes.Float;
                value.FloatValue = float.Parse(context.DECIMAL_NUMBER().GetText());
            }
            else if (context.SINGLE_QUOTED_TEXT() != null)
            {
                value.Type = AttributeTypes.Char;
                string withQuotes = context.SINGLE_QUOTED_TEXT().GetText();
                value.StringValue = withQuotes.Substring(1, withQuotes.Length - 2);
                value.CharLimit   = Encoding.UTF8.GetByteCount(value.StringValue);
            }
            else if (context.DOUBLE_QUOTED_TEXT() != null)
            {
                value.Type = AttributeTypes.Char;
                string withQuotes = context.DOUBLE_QUOTED_TEXT().GetText();
                value.StringValue = withQuotes.Substring(1, withQuotes.Length - 2);
                value.CharLimit   = Encoding.UTF8.GetByteCount(value.StringValue);
            }
            else
            {
                throw new System.NotImplementedException();
            }
            return(value);
        }
Ejemplo n.º 2
0
        private static void TestFullCalculate()
        {
            Expression exp = GetAndsExpression();

            List <AttributeValue> nameValuePairs = new List <AttributeValue>();

            nameValuePairs.Add(new AttributeValue("a", new AtomValue {
                Type = AttributeTypes.Int, IntegerValue = 33
            }));
            nameValuePairs.Add(new AttributeValue("b", new AtomValue {
                Type = AttributeTypes.Char, CharLimit = 5, StringValue = "stc"
            }));
            nameValuePairs.Add(new AttributeValue("c", new AtomValue {
                Type = AttributeTypes.Float, FloatValue = 6.0
            }));

            AtomValue result = exp.Calculate(nameValuePairs);

            Assert.True(result.BooleanValue);

            nameValuePairs[1].Value.StringValue = "stz";

            result = exp.Calculate(nameValuePairs);
            Assert.False(result.BooleanValue);
        }
Ejemplo n.º 3
0
        private SelectResult HandleSelectStatement(ShowStatement statement)
        {
            List <SchemaRecord> tableSchemas = _catalogManager.GetTablesSchemaRecord();
            SelectResult        result       = new SelectResult();

            result.ColumnDeclarations = new List <AttributeDeclaration>()
            {
                new AttributeDeclaration()
                {
                    AttributeName = "Table", Type = AttributeTypes.Char, CharLimit = 80
                }
            };
            result.Rows = new List <List <AtomValue> >();
            foreach (SchemaRecord tableSchema in tableSchemas)
            {
                List <AtomValue> row = new List <AtomValue>();
                AtomValue        col = new AtomValue();
                col.Type        = AttributeTypes.Char;
                col.CharLimit   = 80;
                col.StringValue = tableSchema.Name;
                row.Add(col);
                result.Rows.Add(row);
            }
            return(result);
        }
Ejemplo n.º 4
0
        static void TestInternalIndexCell()
        {
            // init record
            DBRecord record = GetTestBRecord();

            // init key
            List <AtomValue> keyValues = new List <AtomValue>();
            AtomValue        key       = new AtomValue()
            {
                Type = AttributeTypes.Char, CharLimit = 8, StringValue = "114514"
            };

            keyValues.Add(key);
            DBRecord keyRecord = new DBRecord(keyValues);

            // make raw bytes
            List <byte> rawNode = new List <byte>();

            rawNode.AddRange(new byte[30]);

            // build cell
            InternalIndexCell internalIndexCell = new InternalIndexCell(record, 114514, keyRecord);

            byte[] raw = internalIndexCell.Pack();
            rawNode.AddRange(raw);

            // clone
            InternalIndexCell clone = new InternalIndexCell(rawNode.ToArray(), 30);

            // assert
            AssertCell(internalIndexCell, clone);
            Assert.Equal(internalIndexCell.ChildPage, clone.ChildPage);
            AssertDBRecords(internalIndexCell.PrimaryKey, clone.PrimaryKey);
        }
Ejemplo n.º 5
0
        public int CreateIndex(int tableRootPage, string indexedColumnName, List <AttributeDeclaration> attributeDeclarations)
        {
            BTreeNode indexRoot = _bTree.OccupyNewTableNode();
            BTreeNode tableRoot = BTreeNodeHelper.GetBTreeNode(_pager, tableRootPage);

            int indexedColumnIndex = attributeDeclarations.FindIndex(x => x.AttributeName == indexedColumnName);

            foreach (BTreeCell tableCell in _bTree.LinearSearch(tableRoot))
            {
                AtomValue indexedValue = ((LeafTableCell)tableCell).DBRecord.GetValues()[indexedColumnIndex];
                AtomValue primaryKey   = ((LeafTableCell)tableCell).Key.GetValues()[0];
                // List<AtomValue> indexPrimaryKeyPair = new List<AtomValue>() { indexedValue, primaryKey };
                List <AtomValue> wrappedPrimaryKey = new List <AtomValue>()
                {
                    primaryKey
                };
                DBRecord wrappedKey = new DBRecord(new List <AtomValue>()
                {
                    indexedValue
                });
                // DBRecord wrappedValues = new DBRecord(indexPrimaryKeyPair);
                DBRecord wrappedValues = new DBRecord(wrappedPrimaryKey);
                indexRoot = _bTree.InsertCell(indexRoot, wrappedKey, wrappedValues);
            }

            return(indexRoot.RawPage.PageNumber);
        }
Ejemplo n.º 6
0
        static void TestLeafTableCell()
        {
            // init record
            DBRecord record = GetTestBRecord();

            // init key
            List <AtomValue> keyValues = new List <AtomValue>();
            AtomValue        key       = new AtomValue()
            {
                Type = AttributeTypes.Char, CharLimit = 8, StringValue = "114514"
            };

            keyValues.Add(key);
            DBRecord keyRecord = new DBRecord(keyValues);

            // make raw bytes
            List <byte> rawNode = new List <byte>();

            rawNode.AddRange(new byte[30]);

            // build cell
            LeafTableCell leafTableCell = new LeafTableCell(keyRecord, record);

            byte[] raw = leafTableCell.Pack();
            rawNode.AddRange(raw);

            // clone
            LeafTableCell leafTableCellClone = new LeafTableCell(rawNode.ToArray(), 30);

            // assert
            AssertDBRecords(leafTableCell.DBRecord, leafTableCellClone.DBRecord);
            AssertCell(leafTableCell, leafTableCellClone);
        }
Ejemplo n.º 7
0
        public static AtomValue operator +(AtomValue leftValue, AtomValue rightValue)
        {
            ThrowErrorIfNotSameType(leftValue, rightValue);
            AtomValue result = new AtomValue();

            result.Type = leftValue.Type;
            switch (leftValue.Type)
            {
            case AttributeTypes.Char:
                result.StringValue = leftValue.StringValue + rightValue.StringValue;
                break;

            case AttributeTypes.Float:
                result.FloatValue = leftValue.FloatValue + rightValue.FloatValue;
                break;

            case AttributeTypes.Int:
                result.IntegerValue = leftValue.IntegerValue + rightValue.IntegerValue;
                break;

            case AttributeTypes.Null:
                throw new System.NullReferenceException();
            }
            return(result);
        }
Ejemplo n.º 8
0
        static DBRecord GetTestBRecord(int key = 222)
        {
            // init record
            List <AtomValue> values = new List <AtomValue>();
            AtomValue        value1 = new AtomValue()
            {
                Type = AttributeTypes.Int, IntegerValue = key
            };
            AtomValue value2 = new AtomValue()
            {
                Type = AttributeTypes.Null
            };
            AtomValue value3 = new AtomValue()
            {
                Type = AttributeTypes.Char, CharLimit = 5, StringValue = "222"
            };

            values.Add(value1);
            values.Add(value2);
            values.Add(value3);
            DBRecord record      = new DBRecord(values);
            DBRecord cloneRecord = new DBRecord(record.Pack(), 0);

            AssertDBRecords(record, cloneRecord);
            return(record);
        }
Ejemplo n.º 9
0
 static void AssertAtomValue(AtomValue v1, AtomValue v2)
 {
     Assert.Equal(v1.Type, v2.Type);
     Assert.Equal(v1.CharLimit, v2.CharLimit);
     Assert.Equal(v1.FloatValue, v2.FloatValue);
     Assert.Equal(v1.IntegerValue, v2.IntegerValue);
     Assert.Equal(v1.StringValue, v2.StringValue);
 }
Ejemplo n.º 10
0
 private static void ThrowErrorIfNotSameType(AtomValue leftValue, AtomValue rightValue)
 {
     // make sure the types of children are the same
     if (leftValue?.Type != rightValue?.Type)
     {
         throw new System.Exception("Operands type not matched!");
     }
 }
Ejemplo n.º 11
0
 static void AssertAtomValue(AtomValue v1, AtomValue v2)
 {
     Debug.Assert(v1.Type == v2.Type);
     Debug.Assert(v1.CharLimit == v2.CharLimit);
     Debug.Assert(v1.FloatValue == v2.FloatValue);
     Debug.Assert(v1.IntegerValue == v2.IntegerValue);
     Debug.Assert(v1.StringValue == v2.StringValue);
 }
Ejemplo n.º 12
0
        public override bool Equals(AtomValue other)
        {
            IntValue o = (IntValue)other;

            if (o != null)
            {
                return(this.value == o.value);
            }
            return(false);
        }
Ejemplo n.º 13
0
        private static void TestCalculateSingleValue()
        {
            Expression andsExpression = GetAndsExpression();
            string     attributeName  = "b";
            AtomValue  attributeValue = new AtomValue();

            attributeValue.Type        = AttributeTypes.Char;
            attributeValue.CharLimit   = 10;
            attributeValue.StringValue = "aaa";
            Assert.True(andsExpression.CheckKey(attributeName, attributeValue));
        }
Ejemplo n.º 14
0
        // return new root page number
        public int InsertRecord(List <AtomValue> values, AtomValue key, int rootPage)
        {
            BTreeNode node       = BTreeNodeHelper.GetBTreeNode(_pager, rootPage);
            DBRecord  wrappedKey = new DBRecord(new List <AtomValue>()
            {
                key
            });
            DBRecord  wrappedValues = new DBRecord(values);
            BTreeNode newRoot       = _bTree.InsertCell(node, wrappedKey, wrappedValues);

            return(newRoot.RawPage.PageNumber);
        }
Ejemplo n.º 15
0
        public static AtomValue operator <(AtomValue leftValue, AtomValue rightValue)
        {
            AtomValue result = new AtomValue();

            result.Type = AttributeTypes.Int;
            switch (leftValue.Type)
            {
            case AttributeTypes.Char:
                ThrowErrorIfNotSameType(leftValue, rightValue);
                result.IntegerValue = string.Compare(leftValue.StringValue, rightValue.StringValue) < 0 ? 1 : 0;
                break;

            case AttributeTypes.Float:
                switch (rightValue.Type)
                {
                case AttributeTypes.Int:
                    result.IntegerValue = leftValue.FloatValue < rightValue.IntegerValue ? 1 : 0;
                    break;

                case AttributeTypes.Float:
                    result.IntegerValue = leftValue.FloatValue < rightValue.FloatValue ? 1 : 0;
                    break;

                default:
                    ThrowErrorIfNotSameType(leftValue, rightValue);
                    break;
                }
                break;

            case AttributeTypes.Int:
                switch (rightValue.Type)
                {
                case AttributeTypes.Int:
                    result.IntegerValue = leftValue.IntegerValue < rightValue.IntegerValue ? 1 : 0;
                    break;

                case AttributeTypes.Float:
                    result.IntegerValue = leftValue.IntegerValue < rightValue.FloatValue ? 1 : 0;
                    break;

                default:
                    ThrowErrorIfNotSameType(leftValue, rightValue);
                    break;
                }
                result.IntegerValue = leftValue.IntegerValue < rightValue.IntegerValue ? 1 : 0;
                break;

            case AttributeTypes.Null:
                throw new System.NullReferenceException();
            }
            return(result);
        }
Ejemplo n.º 16
0
        private static DBRecord GetTestKey_expression(int value_1)
        {
            List <AtomValue> values = new List <AtomValue>();
            AtomValue        value1 = new AtomValue()
            {
                Type = AttributeTypes.Int, IntegerValue = value_1
            };

            values.Add(value1);
            DBRecord record = new DBRecord(values);

            return(record);
        }
Ejemplo n.º 17
0
        // return null if not found
        public List <AtomValue> SelectRecord(AtomValue key, int rootPage)
        {
            List <AtomValue> wrapper = new List <AtomValue> {
                key
            };
            DBRecord         keyDBRecord = new DBRecord(wrapper);
            BTreeNode        node        = BTreeNodeHelper.GetBTreeNode(_pager, rootPage);
            BTreeCell        cell        = _bTree.FindCell(keyDBRecord, node);
            List <AtomValue> result      = null;

            result = ((LeafTableCell)cell)?.DBRecord.GetValues();
            return(result);
        }
Ejemplo n.º 18
0
        private static void TestAtomValueOperators()
        {
            AtomValue left  = new AtomValue();
            AtomValue right = new AtomValue();

            left.StringValue   = "abedeb";
            left.IntegerValue  = 114;
            left.FloatValue    = 14.14;
            right.StringValue  = "abeceb";
            right.IntegerValue = 514;
            right.FloatValue   = 14.14;

            left.Type  = AttributeTypes.Char;
            right.Type = AttributeTypes.Char;
            Debug.Assert((left < right).BooleanValue == false);
            Debug.Assert((left > right).BooleanValue == true);
            Debug.Assert((left == right).BooleanValue == false);
            Debug.Assert((left != right).BooleanValue == true);
            Debug.Assert((left <= right).BooleanValue == false);
            Debug.Assert((left >= right).BooleanValue == true);
            Debug.Assert((left + right).StringValue == "abedebabeceb");

            left.Type  = AttributeTypes.Int;
            right.Type = AttributeTypes.Int;
            Debug.Assert((left < right).BooleanValue == true);
            Debug.Assert((left > right).BooleanValue == false);
            Debug.Assert((left == right).BooleanValue == false);
            Debug.Assert((left != right).BooleanValue == true);
            Debug.Assert((left <= right).BooleanValue == true);
            Debug.Assert((left >= right).BooleanValue == false);
            Debug.Assert((left + right).IntegerValue == 628);
            Debug.Assert((left - right).IntegerValue == -400);
            Debug.Assert((left * right).IntegerValue == 114 * 514);
            Debug.Assert((left / right).IntegerValue == 114 / 514);

            left.Type  = AttributeTypes.Float;
            right.Type = AttributeTypes.Float;
            Debug.Assert((left < right).BooleanValue == false);
            Debug.Assert((left > right).BooleanValue == false);
            Debug.Assert((left == right).BooleanValue == true);
            Debug.Assert((left != right).BooleanValue == false);
            Debug.Assert((left <= right).BooleanValue == true);
            Debug.Assert((left >= right).BooleanValue == true);
            Debug.Assert((left + right).FloatValue == 28.28);
            Debug.Assert((left - right).FloatValue == 0.0);
            Debug.Assert((left * right).FloatValue == 14.14 * 14.14);
            Debug.Assert((left / right).FloatValue == 1);
        }
Ejemplo n.º 19
0
        private static void TestAtomValueOperators()
        {
            AtomValue left  = new AtomValue();
            AtomValue right = new AtomValue();

            left.StringValue   = "abedeb";
            left.IntegerValue  = 114;
            left.FloatValue    = 14.14;
            right.StringValue  = "abeceb";
            right.IntegerValue = 514;
            right.FloatValue   = 14.14;

            left.Type  = AttributeTypes.Char;
            right.Type = AttributeTypes.Char;
            Assert.False((left < right).BooleanValue);
            Assert.True((left > right).BooleanValue);
            Assert.False((left == right).BooleanValue);
            Assert.True((left != right).BooleanValue);
            Assert.False((left <= right).BooleanValue);
            Assert.True((left >= right).BooleanValue);
            Assert.Equal("abedebabeceb", (left + right).StringValue);

            left.Type  = AttributeTypes.Int;
            right.Type = AttributeTypes.Int;
            Assert.True((left < right).BooleanValue);
            Assert.False((left > right).BooleanValue);
            Assert.False((left == right).BooleanValue);
            Assert.True((left != right).BooleanValue);
            Assert.True((left <= right).BooleanValue);
            Assert.False((left >= right).BooleanValue);
            Assert.Equal(628, (left + right).IntegerValue);
            Assert.Equal(-400, (left - right).IntegerValue);
            Assert.Equal(114 * 514, (left * right).IntegerValue);
            Assert.Equal(114 / 514, (left / right).IntegerValue);

            left.Type  = AttributeTypes.Float;
            right.Type = AttributeTypes.Float;
            Assert.False((left < right).BooleanValue);
            Assert.False((left > right).BooleanValue);
            Assert.True((left == right).BooleanValue);
            Assert.False((left != right).BooleanValue);
            Assert.True((left <= right).BooleanValue);
            Assert.True((left >= right).BooleanValue);
            Assert.Equal(28.28, (left + right).FloatValue);
            Assert.Equal(0.0, (left - right).FloatValue);
            Assert.Equal(14.14 * 14.14, (left * right).FloatValue);
            Assert.Equal(1, (left / right).FloatValue);
        }
Ejemplo n.º 20
0
        private static void TestInsertRandomRecord(int maxCell)
        {
            string dbPath = "./testdbfile.minidb";

            File.Delete(dbPath);
            Pager           pager      = new Pager(dbPath);
            FreeList        freeList   = new FreeList(pager);
            BTreeController controller = new BTreeController(pager, freeList);

            RecordContext recordManager = new RecordContext(pager, controller);

            // create new table
            CreateStatement createStatement = GetCreateStatement();
            int             newRoot         = recordManager.CreateTable();

            // insert
            BTreeNode       node;
            InsertStatement insertStatement;
            int             key;
            int             newRootAfterInsert = newRoot;
            int             i;

            for (i = 0; i < maxCell; i++)
            {
                (insertStatement, key) = GetInsertStatement(1);
                AtomValue atomValue = GetAtomValue(key);

                newRootAfterInsert = recordManager.InsertRecord(insertStatement.Values, atomValue, newRootAfterInsert);
                Console.WriteLine(key);
                Debug.Assert(newRoot == newRootAfterInsert);
            }
            node = BTreeNodeHelper.GetBTreeNode(pager, newRootAfterInsert);
            BTreeNodeHelper.VisualizeIntegerTree(pager, node);
            Console.WriteLine();

            for (i = 0; i < maxCell; i++)
            {
                (insertStatement, key) = GetInsertStatement(1);
                AtomValue atomValue = GetAtomValue(key);
                newRootAfterInsert = recordManager.InsertRecord(insertStatement.Values, atomValue, newRootAfterInsert);
                Console.WriteLine(key);
            }
            node = BTreeNodeHelper.GetBTreeNode(pager, newRootAfterInsert);
            BTreeNodeHelper.VisualizeIntegerTree(pager, node);

            pager.Close();
        }
Ejemplo n.º 21
0
        static void TestDBRecord()
        {
            // init record
            List <AtomValue> values = new List <AtomValue>();
            AtomValue        value1 = new AtomValue()
            {
                Type = AttributeTypes.Int, IntegerValue = 222
            };
            AtomValue value2 = new AtomValue()
            {
                Type = AttributeTypes.Null
            };
            AtomValue value3 = new AtomValue()
            {
                Type = AttributeTypes.Char, CharLimit = 5, StringValue = "222"
            };

            values.Add(value1);
            values.Add(value2);
            values.Add(value3);
            DBRecord record = new DBRecord(values);

            // make raw bytes
            List <byte> rawNode = new List <byte>();

            rawNode.AddRange(new byte[30]);

            // clone
            List <AtomValue> valuesOut1 = record.GetValues();

            // clone
            byte[] raw = record.Pack();
            rawNode.AddRange(raw);
            record.Unpack(rawNode.ToArray(), 30);
            List <AtomValue> valuesOut2 = record.GetValues();

            int i;

            for (i = 0; i < valuesOut2.Count; i++)
            {
                AssertAtomValue(values[i], valuesOut2[i]);
                AssertAtomValue(valuesOut1[i], valuesOut2[i]);
            }
        }
Ejemplo n.º 22
0
        private void HandleStatement(InsertStatement statement)
        {
            _catalogManager.CheckValidation(statement);
            // get table schema
            SchemaRecord schema = _catalogManager.GetTableSchemaRecord(statement.TableName);

            // adjust inlined type in insert statement
            if (schema.SQL.AttributeDeclarations.Count != statement.Values.Count)
            {
                throw new Exception("number of columns between \"create table\" and \"insert statement\' do not match");
            }
            int i;

            for (i = 0; i < statement.Values.Count; i++)
            {
                statement.Values[i].CharLimit = schema.SQL.AttributeDeclarations[i].CharLimit;
            }
            // find out primary key from insert values
            AtomValue primaryKey =
                statement.Values[schema.SQL.AttributeDeclarations.FindIndex(x =>
                                                                            x.AttributeName == schema.SQL.PrimaryKey)];
            // insert into index trees
            List <SchemaRecord> indexSchemas = _catalogManager.GetIndicesSchemaRecord(statement.TableName);

            foreach (SchemaRecord indexSchema in indexSchemas)
            {
                // find indexed value from insert values
                AtomValue indexedValue =
                    statement.Values[schema.SQL.AttributeDeclarations.FindIndex(x =>
                                                                                x.AttributeName == indexSchema.SQL.AttributeName)];
                // wrap up indexed value and primary key
                List <AtomValue> indexPrimaryKeyPair = new List <AtomValue>()
                {
                    indexedValue, primaryKey
                };
                // insert into index trees
                int newIndexRoot = _recordManager.InsertRecord(indexPrimaryKeyPair, indexedValue, indexSchema.RootPage);
                _catalogManager.TryUpdateSchemaRecord(indexSchema.Name, newIndexRoot);
            }
            // insert into table tree
            int newRoot = _recordManager.InsertRecord(statement.Values, primaryKey, schema.RootPage);

            _catalogManager.TryUpdateSchemaRecord(statement.TableName, newRoot);
        }
Ejemplo n.º 23
0
        public static AtomValue operator !(AtomValue leftValue)
        {
            AtomValue result = new AtomValue();

            result.Type = AttributeTypes.Int;
            switch (leftValue.Type)
            {
            case AttributeTypes.Char:
                throw new System.InvalidOperationException("String could not Not");

            case AttributeTypes.Float:
            case AttributeTypes.Int:
                result.IntegerValue = leftValue.BooleanValue ? 0 : 1;
                break;

            case AttributeTypes.Null:
                throw new System.NullReferenceException();
            }
            return(result);
        }
Ejemplo n.º 24
0
        // get stored values in models (objects)
        public List <AtomValue> GetValues()
        {
            List <AtomValue> values = new List <AtomValue>();
            int i;

            for (i = 0; i < this.HeaderList.Count; i++)
            {
                AtomValue value       = new AtomValue();
                uint      headerValue = this.HeaderList[i];
                if (headerValue == (int)HeaderValue.INTEGER)
                {
                    value.Type         = AttributeTypes.Int;
                    value.IntegerValue = BitConverter.ToInt32(this.FieldData, this.FieldOffsets[i]);
                }
                else if (headerValue == (int)HeaderValue.FloatingPoint)
                {
                    value.Type       = AttributeTypes.Float;
                    value.FloatValue = BitConverter.ToDouble(this.FieldData, this.FieldOffsets[i]);
                }
                else if (headerValue == (int)HeaderValue.NULL)
                {
                    value.Type = AttributeTypes.Null;
                }
                else if ((headerValue - (int)HeaderValue.TEXT) % 2 == 0)
                {
                    value.Type = AttributeTypes.Char;
                    int stringLength = (int)(headerValue - (uint)HeaderValue.TEXT) / 2;
                    value.CharLimit   = stringLength;
                    value.StringValue = Encoding.UTF8.GetString(this.FieldData, this.FieldOffsets[i], stringLength).TrimEnd('\0');
                }
                else
                {
                    throw new Exception($"Header value {headerValue} does not exists");
                }

                values.Add(value);
            }
            return(values);
        }
Ejemplo n.º 25
0
        private static DBRecord GetTestRecord_expression(int value_1, string value_2, float value_3)
        {
            List <AtomValue> values = new List <AtomValue>();
            AtomValue        value1 = new AtomValue()
            {
                Type = AttributeTypes.Int, IntegerValue = value_1
            };
            AtomValue value2 = new AtomValue()
            {
                Type = AttributeTypes.Char, CharLimit = 5, StringValue = value_2
            };
            AtomValue value3 = new AtomValue()
            {
                Type = AttributeTypes.Float, FloatValue = value_3
            };

            values.Add(value1);
            values.Add(value2);
            values.Add(value3);
            DBRecord record = new DBRecord(values);

            return(record);
        }
Ejemplo n.º 26
0
        public static AtomValue operator -(AtomValue leftValue)
        {
            AtomValue result = new AtomValue();

            result.Type = leftValue.Type;
            switch (leftValue.Type)
            {
            case AttributeTypes.Char:
                throw new System.InvalidOperationException("String could not Subtract");

            case AttributeTypes.Float:
                result.FloatValue = -leftValue.FloatValue;
                break;

            case AttributeTypes.Int:
                result.IntegerValue = -leftValue.IntegerValue;
                break;

            case AttributeTypes.Null:
                throw new System.NullReferenceException();
            }
            return(result);
        }
Ejemplo n.º 27
0
        public override object VisitAtom([NotNull] MiniSQLParser.AtomContext context)
        {
            Expression obj = new Expression();

            // TODO: review
            if (context.scientific() != null)
            {
                AtomValue atomValue = (AtomValue)Visit(context.scientific());
                obj.Operator      = Operator.AtomConcreteValue;
                obj.ConcreteValue = atomValue;
            }
            else if (context.variable() != null)
            {
                string variableName = context.variable().GetText();
                obj.Operator      = Operator.AtomVariable;
                obj.AttributeName = variableName;
            }
            else
            {
                throw new System.NotImplementedException();
            }
            return(obj);
        }
Ejemplo n.º 28
0
        static DBRecord GetTestBRecord(double height, int pid, string name, string identity, int age)
        {
            // init record
            List <AtomValue> values = new List <AtomValue>();
            AtomValue        value1 = new AtomValue()
            {
                Type = AttributeTypes.Float, FloatValue = height
            };
            AtomValue value2 = new AtomValue()
            {
                Type = AttributeTypes.Int, IntegerValue = pid
            };
            AtomValue value3 = new AtomValue()
            {
                Type = AttributeTypes.Char, CharLimit = 32, StringValue = name
            };
            AtomValue value4 = new AtomValue()
            {
                Type = AttributeTypes.Char, CharLimit = 128, StringValue = identity
            };
            AtomValue value5 = new AtomValue()
            {
                Type = AttributeTypes.Int, IntegerValue = age
            };

            values.Add(value1);
            values.Add(value2);
            values.Add(value3);
            values.Add(value4);
            values.Add(value5);
            DBRecord record      = new DBRecord(values);
            DBRecord cloneRecord = new DBRecord(record.Pack(), 0);

            BTreeNodeHelper.AssertDBRecords(record, cloneRecord);
            return(record);
        }
Ejemplo n.º 29
0
 public AttributeValue(string attributeName, AtomValue value)
 {
     this.Value         = value;
     this.AttributeName = attributeName;
 }
Ejemplo n.º 30
0
        // `keyName` := primary key in table tree; indexed value in index tree
        public List <BTreeCell> FindCells(BTreeNode root, Expression condition, string keyName, List <AttributeDeclaration> attributeDeclarations)
        {
            if (condition == null)
            {
                return(LinearSearch(root, condition, attributeDeclarations));
            }
            else if (condition.SimpleMinterms.ContainsKey(keyName))
            {
                List <BTreeCell> result = new List <BTreeCell>();
                List <AtomValue> values = new List <AtomValue>();
                BTreeNode        startNode;

                BTreeCell cell;
                int       startIndexOfCellInStartNode;

                AtomValue bound = condition.SimpleMinterms[keyName].RightOperand.ConcreteValue;

                values.Add(bound);
                DBRecord keyFind = new DBRecord(values);
                switch (condition.SimpleMinterms[keyName].Operator)
                {
                case Operator.NotEqual:
                    return(LinearSearch(root, condition, attributeDeclarations));

                case Operator.Equal:
                    LeafTableCell tmpCell = (LeafTableCell)FindCell(keyFind, root);
                    if (tmpCell == null)
                    {
                        break;
                    }
                    else if (condition.Calculate(attributeDeclarations, tmpCell.DBRecord.GetValues()).BooleanValue == true)
                    {
                        result.Add(tmpCell);
                    }
                    break;

                case Operator.LessThan:
                    startNode = FindMin(root);
                    return(FindCells(startNode, condition, attributeDeclarations, bound, false));

                case Operator.LessThanOrEqualTo:
                    startNode = FindMin(root);
                    return(FindCells(startNode, condition, attributeDeclarations, bound, true));

                case Operator.MoreThan:
                    startNode = FindNode(keyFind, root, true);
                    // nothing is equal or more than the value of `keyFind` in the tree
                    if (startNode == null)
                    {
                        return(result);
                    }
                    (cell, _, startIndexOfCellInStartNode) = startNode.FindBTreeCell(keyFind);
                    // 2 possible situations for `cell == null`:
                    // 1: The `keyFind` is bigger than all the key in `startNode`
                    // 2: The `keyFind` is just between the bigest one in `startNode` and the smallest one in next node
                    if (cell == null)
                    {
                        if (startNode.RightPage == 0)
                        {
                            return(result);
                        }
                        else
                        {
                            startIndexOfCellInStartNode = 0;
                            MemoryPage nextpage = _pager.ReadPage((int)startNode.RightPage);
                            startNode = new BTreeNode(nextpage);
                        }
                    }
                    return(FindCells(startNode, startIndexOfCellInStartNode, condition, attributeDeclarations, false));

                case Operator.MoreThanOrEqualTo:
                    startNode = FindNode(keyFind, root, true);
                    // nothing is equal or more than the value of `keyFind` in the tree
                    if (startNode == null)
                    {
                        return(result);
                    }
                    (cell, _, startIndexOfCellInStartNode) = startNode.FindBTreeCell(keyFind);
                    if (cell == null)
                    {
                        if (startNode.RightPage == 0)
                        {
                            return(result);
                        }
                        else
                        {
                            startIndexOfCellInStartNode = 0;
                            MemoryPage nextpage = _pager.ReadPage((int)startNode.RightPage);
                            startNode = new BTreeNode(nextpage);
                        }
                    }
                    return(FindCells(startNode, startIndexOfCellInStartNode, condition, attributeDeclarations, true));

                default:
                    throw new Exception("The Operand is not supported!");
                }
                //This step may not need?
                return(result);
            }
            else
            {
                return(LinearSearch(root, condition, attributeDeclarations));
            }
        }