public FunctionDefinition(Type returnType, string name, Type argumentType, string argumentName, Expression body)
 {
     _argument = Tuple.Create(argumentName, argumentType);
     _body = body;
     _returnType = returnType;
     _name = name;
 }
Beispiel #2
0
        public SqlQuery QueryRecords(DatasetInfo dataset, Expression expression)
        {
            var builder = new SqlBuilder(adapter)
                .Select(dataset.Members)
                .From(dataset.Name)
                .Where(expression);

            return new SqlQuery(builder.ToString(), builder.Parameters);
        }
 public SubtractExpression(Expression operand1, Expression operand2)
     : base(operand1, operand2)
 {
     base.symbol = '-';
 }
Beispiel #4
0
 public BinaryOperation(Operator op, Expression e1, Expression e2)
 {
     _op = op;
     _e1 = e1;
     _e2 = e2;
 }
Beispiel #5
0
 void SimExpr(out Expression e)
 {
     Expression e1, e2; Operator op;
     Term(out e1);
     e = e1;
     while (la.kind == 17 || la.kind == 18) {
     AddOp(out op);
     Term(out e2);
     e = new BinaryOperation(op, e, e2);
     }
 }
Beispiel #6
0
 void Factor(out Expression e)
 {
     string name; Expression e1; e = null;
     if (la.kind == 1) {
     Ident(out name);
     e = new Variable(name);
     if (la.kind == 3) {
         Get();
         Expr(out e1);
         Expect(4);
         e = new FunctionCall(name, e1);
     }
     } else if (la.kind == 2) {
     Get();
     e = new Constant(int.Parse(t.val), Type.IntegerType);
     } else if (la.kind == 18) {
     Get();
     Factor(out e1);
     e = new UnaryOperation(Operator.Neg, e1);
     } else if (la.kind == 3) {
     Get();
     Expr(out e1);
     Expect(4);
     e = e1;
     } else SynErr(25);
 }
Beispiel #7
0
 void BoolTerm(out Expression e)
 {
     Expression e1, e2; Operator op; e = null;
     SimBoolExpr(out e1);
     e = e1;
     while (la.kind == 10) {
     OrOp(out op);
     SimBoolExpr(out e2);
     e = new BinaryOperation(op, e, e2);
     }
 }
Beispiel #8
0
 public Program(IDictionary<string, FunctionDefinition> functions, Expression expression)
 {
     _functionEnvironment = new FunctionEnvironment(functions);
     _expression = expression;
 }
 public AddExpression(Expression operand1, Expression operand2)
     : base(operand1, operand2)
 {
     base.symbol = '+';
 }
Beispiel #10
0
        public Expression GetKeyFilter(DatasetInfo schema)
        {
            var conditions = new Expression[schema.PrimaryKey.Size];

            for (var i = 0; i < conditions.Length; i++)
            {
                var key = schema.PrimaryKey[i];

                conditions[i] = Expression.Eq(key.Name, new Symbol("@" + key.PropertyName));
            }

            return Expression.Conjunction(conditions);
        }
Beispiel #11
0
        private Expression Expand(Expression expression, DatasetInfo baseTable)
        {
            if (expression is Symbol)
            {
                var symbol = (Symbol)expression;

                var member = baseTable[symbol.Name];

                var prefix = member.IsKey || member.IsMutable || member.IsVersion ? "v" : "a";

                return new Symbol(prefix, member.Name);
            }
            else if (expression is BinaryExpression)
            {
                var binary = (BinaryExpression)expression;

                var lhs = Expand(binary.Left, baseTable);
                var rhs = Expand(binary.Right, baseTable);

                return new BinaryExpression(lhs, binary.Op, rhs);
            }

            return expression;
        }
Beispiel #12
0
        public SqlQuery QueryVersions(DatasetInfo baseTable, DatasetInfo versionedTable, Expression expression)
        {
            var sql = new SqlBuilder(adapter);

            var v = new SchemaObject(versionedTable.Name, "v");

            var a = new SchemaObject(baseTable.Name, "a");

            sql.Append("SELECT ");

            sql.WriteColumns(versionedTable.Members, prefix: "v"); // mutable values, primary keys, ...

            sql.Append(", ");

            sql.WriteColumns(baseTable.Members.Where(m => !m.IsVersion && !m.IsKey && !m.IsMutable), prefix: "a"); // immutable values from base table

            sql.From(v); // SELECT from v

            var keyName = baseTable.PrimaryKey[0].Name;

            // join the base (immutable) values with the versioned values
            sql.InnerJoin(
                baseTable       : v,        // versioned values
                joinedTable     : a,        // base values
                baseColumn      : keyName, 
                joinedColumn    : keyName
            );

            sql.Where(Expand(expression, baseTable)); 

            return new SqlQuery(sql.ToString(), sql.Parameters);
        }
Beispiel #13
0
 public FunctionCall(string name, Expression arg)
 {
     _name = name;
     _arg = arg;
 }
 protected UnaryExpression(Expression operand1)
 {
     this.operand1 = operand1;
 }
Beispiel #15
0
        public SqlQuery QueryFirst(DatasetInfo dataset, Expression expression)
        {
            var sql = new SqlBuilder(adapter)
                .Select(dataset.Members)
                .From(dataset.Name)
                .Where(expression)
                .Limit(1);

            return new SqlQuery(sql.ToString(), sql.Parameters);
        }
 protected BinaryExpression(Expression operand1, Expression operand2)
 {
     this.operand1 = operand1;
     this.operand2 = operand2;
 }
Beispiel #17
0
        public object ProcessPart(object val)
        {
            if (DEBUG) Console.WriteLine("Process part");

            if (val != null)
            {
                if (expr[_offset] != '.')
                    throw new FormatException("Invalid symbol: " + expr[_offset]);
                _offset++;
            }

            var c = expr[_offset];
            if (DEBUG) Console.WriteLine(_offset + ": " + c);

            if (c == '\'' || c == '"') // String expression
            {
                return ReadString();
            }

            if (Char.IsDigit(c))
            {
                return ReadDigit();
            }

            if (Char.IsLetter(c)) // Variable
            {
                string word = ReadWord();
                if (DEBUG) Console.WriteLine("Word: " + word);

                if (Search('(')) // Method calling
                {
                    if (DEBUG) Console.WriteLine("Method: " + val + "." + word);

                    string argStr = ReadBracers().Trim();
                    if (argStr.Length > 0)
                    {
                        string[] argParts = argStr.Split(',');
                        object[] args = new object[argParts.Length];
                        for (int i = 0; i < argParts.Length; i++)
                        {
                            object arg = new Expression(argParts[i], _scopes).Process();
                            args[i] = arg;
                        }

                        if (DEBUG) Console.WriteLine("Call: " + word + "(" + String.Join(", ", args) + ")");
                        return Call(val, word, args);
                    }
                    else
                    {
                        if (DEBUG) Console.WriteLine("Call: " + word + "()");
                        return Call(val, word);
                    }
                }
                else // Variable or property
                {
                    if (val == null) // TODO Check on first word, because it can be property or method result
                    {
                        if (DEBUG) Console.WriteLine("Variable: " + word);
                        return GetVariable(word);
                    }
                    else
                    {
                        if (DEBUG) Console.WriteLine("Property: " + word + " of " + val);
                        return GetProperty(val, word);
                    }
                }
            }

            if (c == '(')
            {
                string argStr = ReadBracers();
                object arg = new Expression(argStr, _scopes).Process();
                return arg;
            }

            throw new FormatException(String.Format("Wrong symbol '{0}' at {1}", c, _offset));
        }
 public DivideExpression(Expression operand1, Expression operand2)
     : base(operand1, operand2)
 {
     base.symbol = '/';
 }
 public ModulusExpression(Expression operand1, Expression operand2)
     : base(operand1, operand2)
 {
     base.symbol = '%';
 }
Beispiel #20
0
 public UnaryOperation(Operator op, Expression expression)
 {
     _op = op;
     _expression = expression;
 }
 public MultiplyExpression(Expression operand1, Expression operand2)
     : base(operand1, operand2)
 {
     base.symbol = '*';
 }
Beispiel #22
0
 void Expr(out Expression e)
 {
     Expression e1, e2; Operator op; e = null;
     BoolTerm(out e1);
     e = e1;
     while (la.kind == 9) {
     AndOp(out op);
     BoolTerm(out e2);
     e = new BinaryOperation(op, e, e2);
     }
 }
 public NegateExpression(Expression operand1)
     : base(operand1)
 {
     base.symbol = '!';
 }
Beispiel #24
0
 void SimBoolExpr(out Expression e)
 {
     Expression e1, e2; Operator op; e = null;
     SimExpr(out e1);
     e = e1;
     if (StartOf(1)) {
     RelOp(out op);
     SimExpr(out e2);
     e = new BinaryOperation(op, e, e2);
     }
 }
 public PowerExpression(Expression operand1, Expression operand2)
     : base(operand1, operand2)
 {
     base.symbol = '^';
 }
Beispiel #26
0
 void Term(out Expression e)
 {
     Operator op; Expression e1, e2;
     Factor(out e1);
     e = e1;
     while (la.kind == 19 || la.kind == 20) {
     MulOp(out op);
     Factor(out e2);
     e = new BinaryOperation(op, e, e2);
     }
 }
Beispiel #27
0
        // BinaryOperationRHS ::= ('+' primary)*
        private Expression ParseBinaryOperationRHS(Lexer lexer, int previousPrecedence, Expression LHS)
        {
            while (true)
            {
                // get current token and find its precedence
                var currentToken = lexer.Next();
                int currentPrecedence = GetTokenPrecedence(currentToken);

                // if the current precedence is less that the previous, return LHS as it is
                if (currentPrecedence < previousPrecedence)
                {
                    lexer.UnGet(currentToken);
                    return LHS;
                }

                var operation = (currentToken as BinaryOperatorLexToken).Value();
                // otherwise, parse out the RHS
                var RHS = ParsePrimary(lexer);
                if (RHS == null)
                {
                    return null;
                }

                // If BinOp binds less tightly with RHS than the operator after RHS, let
                // the pending operator take RHS as its LHS.
                var tokenAfterRHS = lexer.Next();
                lexer.UnGet(tokenAfterRHS);
                var afterRHSPrecendence = GetTokenPrecedence(tokenAfterRHS);
                if (currentPrecedence < afterRHSPrecendence)
                {
                    RHS = ParseBinaryOperationRHS(lexer, currentPrecedence + 1, RHS);
                }

                // merge LHS and RHS
                LHS = new BinaryOperatorExpression(operation, LHS, RHS);
            }
        }