Esempio n. 1
0
        internal override bool SelectTable(string table)
        {
            _table = table;
            var path = GetPath();

            if (!File.Exists(path))
            {
                return(false);
            }
            using (var rdr = new TextFieldParser(path)
            {
                TextFieldType = FieldType.Delimited,
                Delimiters = new string[] { "," },
            }) {
                var row = rdr.ReadFields();
                if (_hasid)
                {
                    row = (new string[] { "Id:number" })
                          .Concat(row).ToArray();
                }
                var fields = row.Select(r => new CommonField {
                    Name = r, CType = CommonType.Text
                }).ToArray();
                Heading = CommonHeading.Create(fields);
            }
            return(true);
        }
Esempio n. 2
0
        // remove tuples that satisfy predicate
        public void Delete(string heading, Func <Tup, bool> selfunc)
        {
            var head = CommonHeading.Create(heading);
            var map  = head.CreateMap(Heading);

            Value = new RelValue(Heading, Value.Where(t => !selfunc(RelStatic.CreateByMap <Tup>(t, map))));
        }
Esempio n. 3
0
        static IEnumerable <TupBase> While(CommonHeading heading, IEnumerable <TupBase> body, Func <RelNode, RelNode> func)
        {
            var stack = new Stack <TupBase>(body);
            var hash  = new HashSet <TupBase>();

            while (stack.Count > 0)
            {
                var top = stack.Pop();
                if (!hash.Contains(top))
                {
                    hash.Add(top);
                    var result = func(new WrapperNode(heading, Enumerable.Repeat(top, 1)));
                    var eq     = result.Heading.IsEqual(heading);
                    var map    = heading.CreateMap(result.Heading);
                    if (result.Heading.Degree != heading.Degree ||
                        map.Any(x => x < 0))
                    {
                        throw Error.Fatal("While", $"heading mismatch: {result.Heading} {heading}");
                    }
                    // convert compatible if needed
                    foreach (var t in result)
                    {
                        stack.Push(eq ? t : RelStatic.CreateByMap <Tup>(t, map));
                    }
                }
            }
            return(hash);
        }
Esempio n. 4
0
 public RenameNode(RelNode source, CommonHeading nodeheading)
 {
     _source      = source;
     _nodeheading = nodeheading;
     _map         = _nodeheading.CreateMap(_source.Heading);
     if (!(_map.Length == 2 && _map[0] >= 0 && _map[1] < 0))
     {
         throw Error.Fatal("Rename", "heading is invalid");
     }
     Heading = _source.Heading.Rename(_nodeheading[0], _nodeheading[1]);
 }
Esempio n. 5
0
        // update tuples that satisfy predicate
        public void Update(string heading, Func <Tup, bool> selfunc, object newvalue)
        {
            // map for selection tuple
            var head1 = CommonHeading.Create(heading);
            var map1  = head1.CreateMap(Heading);
            // map for replace tuple
            var head2 = Heading.Remove(head1.Fields.Last()).Append(CommonField.Empty);
            var map2  = head2.CreateMap(Heading);

            Value = new RelValue(Heading, Value.Select(t => selfunc(RelStatic.CreateByMap <Tup>(t, map1))
        ? RelStatic.CreateByMap <Tup>(t, map2, newvalue) : t));
        }
Esempio n. 6
0
        // select the schema as the current table
        bool SelectSchema()
        {
            _table = null;
            var schema = GetSchema();
            var scols  = schema.Columns;
            var fields = Enumerable.Range(0, scols.Count)
                         .Select(x => new CommonField {
                Name = scols[x].ColumnName, CType = CommonConverter.TypeToCommon(scols[x].DataType)
            }).ToArray();

            Heading = CommonHeading.Create(fields);
            return(true);
        }
Esempio n. 7
0
        public RestrictNode(RelNode source, CommonHeading nodeheading, RelFuncBase func)
        {
            _source      = source;
            _restheading = nodeheading;
            _restfunc    = func;

            Heading  = _source.Heading;
            _restmap = _restheading.CreateMap(Heading);
            if (_restmap.Any(x => x < 0))
            {
                throw Error.Fatal("Restrict", "heading has unknown attribute");
            }
        }
Esempio n. 8
0
        //--- impl

        // reflection hack to get heading value from tuple
        // TODO: is this the best way to handle heading not found?
        internal static CommonHeading GetHeading(Type ttype)
        {
            var prop = ttype.GetField("Heading");

            if (prop == null)
            {
                return(CommonHeading.Empty);
            }
            var heading = (string)prop.GetValue(null);

            if (heading == null)
            {
                return(CommonHeading.Empty);
            }
            return(CommonHeading.Create(heading)); // TODO: add types
        }
Esempio n. 9
0
        public ProjectNode(RelNode source, CommonHeading nodeheading, bool isremove = false)
        {
            _source = source;
            var _nodeheading = nodeheading;

            Heading = (isremove) ? _source.Heading.Minus(_nodeheading) : _nodeheading;
            _map    = Heading.CreateMap(_source.Heading);
            if (Heading.Degree > _source.Heading.Degree)
            {
                throw Error.Fatal("Project", "too many attributes");
            }
            if (_map.Any(x => x < 0))
            {
                throw Error.Fatal("Project", "heading does not match");
            }
        }
Esempio n. 10
0
        public AggregateNode(RelNode source, CommonHeading nodeheading, RelFuncBase func, object initial = null)
        {
            _source  = source;
            _heading = nodeheading;
            _func    = func;
            _initial = initial;

            Heading = _source.Heading.Rename(_heading[0], _heading[1]);
            _vmap   = _heading.CreateMap(_source.Heading);
            _jhead  = _source.Heading.Minus(_heading);
            _jmap1  = _jhead.CreateMap(_source.Heading);
            _jmap2  = Heading.CreateMap(_jhead);
            if (!(_heading.Degree == 2 && _jmap2.Length == Heading.Degree))
            {
                throw Error.Fatal("Aggregate", "heading is not valid");
            }
        }
Esempio n. 11
0
        public UngroupNode(RelNode source, UngroupingOp op, CommonHeading nodeheading)
        {
            _source      = source;
            _op          = op;
            _nodeheading = nodeheading;
            _nodemap     = _nodeheading.CreateMap(_source.Heading);
            if (!(_nodemap.Length == 1 && _nodemap[0] >= 0))
            {
                throw Error.Fatal("Ungroup", "heading is not valid");
            }
            // on output replace one field by the TVA/RVA
            Heading = _source.Heading.Remove(_nodeheading[0]).Append(_nodeheading[0].Fields);
            //
            var tupheading = CommonHeading.Create(_nodeheading[0].Fields);

            _map1 = Heading.CreateMap(_source.Heading);
            _map2 = Heading.CreateMap(tupheading);
        }
Esempio n. 12
0
        public GroupNode(RelNode source, GroupingOp op, CommonHeading nodeheading)
        {
            _source      = source;
            _op          = op;
            _nodeheading = nodeheading;
            // inner tuple(s) for TVA or RVA
            var tupheading = _nodeheading.Remove(_nodeheading.Fields.Last());

            _tmap = tupheading.CreateMap(_source.Heading);
            // outer fields used as key for index
            var keyheading = _source.Heading.Minus(tupheading);

            _kmap = keyheading.CreateMap(_source.Heading);
            // final result with new field appended
            Heading = keyheading.Append(new CommonField(_nodeheading.Fields.Last().Name,
                                                        (_op == GroupingOp.Group) ? CommonType.Table : CommonType.Row, tupheading.Fields));
            _map = Heading.CreateMap(keyheading);
            if (!(_tmap.All(x => x >= 0) && _kmap.All(x => x >= 0) && _map.Last() < 0))
            {
                throw Error.Fatal("Group", "heading is not valid");
            }
        }
Esempio n. 13
0
        public ExtendNode(RelNode source, CommonHeading nodeheading, RelFuncBase func)
        {
            _source      = source;
            _nodeheading = nodeheading;
            _func        = func;

            Heading = CommonHeading.Create(_source.Heading.Fields.Union(_nodeheading.Fields));
            // get the argument fields
            _argheading = CommonHeading.Create(_nodeheading.Fields.Take(_nodeheading.Fields.Length - 1));
            _argmap     = _argheading.CreateMap(_source.Heading);
            // last field can extend or replace, remove name but retain place
            var outh = Heading.Rename(_nodeheading.Fields.Last(), CommonField.Empty);

            _outmap = Heading.CreateMap(outh);
            if (_argmap.Any(x => x < 0))
            {
                throw Error.Fatal("Extend", "heading has unknown attribute");
            }
            if (_outmap.Count(x => x < 0) != 1)
            {
                throw Error.Fatal("Extend", "invalid heading, invalid new attribute");                           // any use?
            }
        }
Esempio n. 14
0
 // Generic input
 internal override bool SelectTable(string table)
 {
     //Logger.WriteLine(2, "Sql Peek '{0}'", table);
     if (table == null)
     {
         return(SelectSchema());
     }
     using (var reader = Open(table)) {
         if (reader == null)
         {
             return(false);
         }
         _table = table;
         //Logger.WriteLine(3, "Table {0} fields {1}", table, String.Join(",", s));
         var fields = Enumerable.Range(0, reader.FieldCount)
                      .Where(x => _convdict.ContainsKey(reader.GetDataTypeName(x)))
                      .Select(x => new CommonField {
             Name = reader.GetName(x), CType = _convdict[reader.GetDataTypeName(x)]
         }).ToArray();
         Heading = CommonHeading.Create(fields);
     }
     Close();
     return(true);
 }
Esempio n. 15
0
 public RelVarST(RelNode value)
 {
     Heading = RelBaseST <T> .Heading;
     Init(value);
 }
Esempio n. 16
0
 public RelVarST(RelValueST <T> tuples)
 {
     Value   = Rel.Create(tuples);
     Heading = RelBaseST <T> .Heading;
 }
Esempio n. 17
0
 public RelVarST()
 {
     Value   = Rel.Create(new T[0]);
     Heading = RelBaseST <T> .Heading;
 }
Esempio n. 18
0
 // Construct a node from a stream
 public static RelNode Create(string heading, IEnumerable <Tup> source)
 {
     return(new WrapperNode(CommonHeading.Create(heading), source));
 }
Esempio n. 19
0
 public WrapperNode(CommonHeading heading, IEnumerable <TupBase> source)
 {
     _source = source;
     Heading = heading;
 }
Esempio n. 20
0
 // create new relation value from body as enumerable
 public RelValue(CommonHeading heading, IEnumerable <Tup> body)
 {
     Heading = heading;
     _body   = new HashSet <Tup>(body);
 }
Esempio n. 21
0
 // create new relation value from body as set
 public RelValue(CommonHeading heading, HashSet <Tup> body)
 {
     Heading = heading;
     _body   = body;
 }
Esempio n. 22
0
 // Construct a node from literal data
 public static RelNode Data(string heading, params Tup[] source)
 {
     return(new WrapperNode(CommonHeading.Create(heading), source));
 }
Esempio n. 23
0
        //--- ctor

        // set up heading here when relation not instantiated but used to get heading
        static RelBaseST()
        {
            Heading = GetHeading(typeof(T));
        }
Esempio n. 24
0
 public RelBaseST()
 {
     Heading = GetHeading(typeof(T));
     _body   = new HashSet <T>();
 }
Esempio n. 25
0
 // Allow heading to be set as a string "name:type,name:type..."
 internal void SetHeading(string heading)
 {
     Heading = CommonHeading.Create(heading);
 }
Esempio n. 26
0
 public string Format(CommonHeading heading)
 {
     return(Enumerable.Range(0, Values.Length)
            .Select(x => heading[x].Format(Values[x]))
            .Join(", "));
 }