public override object Clone()
        {
            SQLiteColumnType type = null;

            if (_type != null)
            {
                type = (SQLiteColumnType)_type.Clone();
            }
            List <SQLiteColumnConstraint> conslist = null;

            if (_conslist != null)
            {
                conslist = new List <SQLiteColumnConstraint>();
                foreach (SQLiteColumnConstraint cc in _conslist)
                {
                    conslist.Add((SQLiteColumnConstraint)cc.Clone());
                }
            }

            SQLiteObjectName name = null;

            if (this.ObjectName != null)
            {
                name = (SQLiteObjectName)this.ObjectName.Clone();
            }

            SQLiteColumnStatement res = new SQLiteColumnStatement(name);

            res._conslist = conslist;
            res._type     = type;
            return(res);
        }
 public SQLiteCreateViewStatement(bool isTemp, bool ifNotExists, SQLiteObjectName viewName, SQLiteSelectStatement select)
     : base(viewName)
 {
     _isTemp      = isTemp;
     _ifNotExists = ifNotExists;
     _select      = select;
 }
Esempio n. 3
0
        public override object Clone()
        {
            List <SQLiteIndexedColumn> columns = null;

            if (_columns != null)
            {
                columns = new List <SQLiteIndexedColumn>();
                foreach (SQLiteIndexedColumn c in _columns)
                {
                    columns.Add((SQLiteIndexedColumn)c.Clone());
                }
            }

            SQLiteObjectName indexName = null;

            if (this.ObjectName != null)
            {
                indexName = (SQLiteObjectName)this.ObjectName.Clone();
            }

            SQLiteCreateIndexStatement res = new SQLiteCreateIndexStatement(indexName);

            res._columns     = columns;
            res._ifNotExists = _ifNotExists;
            res._isUnique    = _isUnique;
            res._onTable     = _onTable;
            return(res);
        }
Esempio n. 4
0
 public SQLiteFromTable(SQLiteObjectName table, string asName,
                        SQLiteFromIndexed indexed, SQLiteExpression onExpr, List <string> usingOpt)
 {
     _table    = table;
     AsName    = asName;
     _indexed  = indexed;
     _onExpr   = onExpr;
     _usingOpt = usingOpt;
 }
Esempio n. 5
0
 public SQLiteCreateIndexStatement(bool isUnique, SQLiteObjectName indexName, bool ifNotExists,
                                   string onTable, List <SQLiteIndexedColumn> columns)
     : base(indexName)
 {
     _isUnique    = isUnique;
     _ifNotExists = ifNotExists;
     OnTable      = onTable;
     _columns     = columns;
 }
 public SQLiteCreateTriggerStatement(bool isTemp, bool ifNotExists, SQLiteObjectName triggerName,
                                     SQLiteTriggerTime triggerTime, SQLiteTriggerEventClause triggerEventClause, SQLiteObjectName table,
                                     bool foreachClause, SQLiteExpression whenExpr)
     : base(triggerName)
 {
     _isTemp             = isTemp;
     _ifNotExists        = ifNotExists;
     _triggerTime        = triggerTime;
     _triggerEventClause = triggerEventClause;
     _table         = table;
     _foreachClause = foreachClause;
     _whenExpr      = whenExpr;
 }
        public override object Clone()
        {
            SQLiteObjectName name = null;

            if (_name != null)
            {
                name = (SQLiteObjectName)_name.Clone();
            }

            SQLiteNameExpression res = new SQLiteNameExpression();

            res._name = name;
            return(res);
        }
Esempio n. 8
0
        public override object Clone()
        {
            SQLiteObjectName objectName = null;

            if (_objectName != null)
            {
                objectName = (SQLiteObjectName)_objectName.Clone();
            }

            SQLiteDdlStatement res = new SQLiteDdlStatement();

            res._objectName = objectName;
            return(res);
        }
        public override object Clone()
        {
            SQLiteTriggerEventClause triggerEventClause = null;

            if (_triggerEventClause != null)
            {
                triggerEventClause = (SQLiteTriggerEventClause)_triggerEventClause.Clone();
            }
            SQLiteObjectName table = null;

            if (_table != null)
            {
                table = (SQLiteObjectName)_table.Clone();
            }
            SQLiteExpression whenExpr = null;

            if (_whenExpr != null)
            {
                whenExpr = (SQLiteExpression)_whenExpr.Clone();
            }
            List <SQLiteStatement> slist = null;

            if (_slist != null)
            {
                slist = new List <SQLiteStatement>();
                foreach (SQLiteStatement s in _slist)
                {
                    slist.Add((SQLiteStatement)s.Clone());
                }
            }
            SQLiteObjectName name = null;

            if (this.ObjectName != null)
            {
                name = (SQLiteObjectName)this.ObjectName.Clone();
            }

            SQLiteCreateTriggerStatement res = new SQLiteCreateTriggerStatement(name);

            res._foreachClause      = _foreachClause;
            res._ifNotExists        = _ifNotExists;
            res._isTemp             = _isTemp;
            res._slist              = slist;
            res._table              = table;
            res._triggerEventClause = triggerEventClause;
            res._triggerTime        = _triggerTime;
            res._whenExpr           = whenExpr;
            return(res);
        }
Esempio n. 10
0
        public virtual object Clone()
        {
            string[] r = null;
            if (_rest != null)
            {
                r = new string[_rest.Length];
                for (int i = 0; i < _rest.Length; i++)
                {
                    r[i] = _rest[i];
                }
            }
            SQLiteObjectName res = new SQLiteObjectName(_first, r);

            return(res);
        }
Esempio n. 11
0
        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return(false);
            }

            SQLiteObjectName dst = obj as SQLiteObjectName;

            if (dst == null)
            {
                return(false);
            }

            return(dst.ToString().ToLower().Equals(this.ToString().ToLower()));
        }
Esempio n. 12
0
        public virtual object Clone()
        {
            SQLiteObjectName t = null;

            if (_table != null)
            {
                t = (SQLiteObjectName)_table.Clone();
            }
            SQLiteFromInternalTable fit = null;

            if (_itable != null)
            {
                fit = (SQLiteFromInternalTable)_itable.Clone();
            }
            SQLiteFromIndexed fi = null;

            if (_indexed != null)
            {
                fi = (SQLiteFromIndexed)_indexed.Clone();
            }
            SQLiteExpression expr = null;

            if (_onExpr != null)
            {
                expr = (SQLiteExpression)_onExpr.Clone();
            }
            List <string> us = null;

            if (_usingOpt != null)
            {
                us = new List <string>();
                foreach (string str in _usingOpt)
                {
                    us.Add(str);
                }
            }

            SQLiteFromTable res = new SQLiteFromTable();

            res._asName   = _asName;
            res._indexed  = fi;
            res._itable   = fit;
            res._onExpr   = expr;
            res._table    = t;
            res._usingOpt = us;
            return(res);
        }
Esempio n. 13
0
        public override object Clone()
        {
            SQLiteExpression expr = null;

            if (_expr != null)
            {
                expr = (SQLiteExpression)_expr.Clone();
            }
            SQLiteSelectStatement select = null;

            if (_select != null)
            {
                select = (SQLiteSelectStatement)_select.Clone();
            }
            SQLiteObjectName table = null;

            if (_table != null)
            {
                table = (SQLiteObjectName)_table.Clone();
            }
            List <SQLiteExpression> exprlist = null;

            if (_exprlist != null)
            {
                exprlist = new List <SQLiteExpression>();
                foreach (SQLiteExpression e in _exprlist)
                {
                    exprlist.Add((SQLiteExpression)e.Clone());
                }
            }

            SQLiteInExpression res = new SQLiteInExpression();

            res._expr     = expr;
            res._exprlist = exprlist;
            res._isIn     = _isIn;
            res._select   = select;
            res._table    = table;
            return(res);
        }
        public virtual object Clone()
        {
            SQLiteExpression expr = null;

            if (_expr != null)
            {
                expr = (SQLiteExpression)_expr.Clone();
            }
            SQLiteObjectName tableName = null;

            if (_tableName != null)
            {
                tableName = (SQLiteObjectName)_tableName.Clone();
            }

            SQLiteSelectColumn res = new SQLiteSelectColumn();

            res._expr      = expr;
            res._asName    = _asName;
            res._tableName = tableName;
            return(res);
        }
        public override object Clone()
        {
            SQLiteSelectStatement select = null;

            if (_select != null)
            {
                select = (SQLiteSelectStatement)_select.Clone();
            }
            SQLiteObjectName viewName = null;

            if (this.ObjectName != null)
            {
                viewName = (SQLiteObjectName)this.ObjectName.Clone();
            }

            SQLiteCreateViewStatement res = new SQLiteCreateViewStatement(viewName);

            res._ifNotExists = _ifNotExists;
            res._isTemp      = _isTemp;
            res._select      = select;
            return(res);
        }
        public override object Clone()
        {
            List <SQLiteColumnStatement> columns = null;

            if (_columns != null)
            {
                columns = new List <SQLiteColumnStatement>();
                foreach (SQLiteColumnStatement cs in _columns)
                {
                    columns.Add((SQLiteColumnStatement)cs.Clone());
                }
            }

            List <SQLiteTableConstraint> constraints = null;

            if (_constraints != null)
            {
                constraints = new List <SQLiteTableConstraint>();
                foreach (SQLiteTableConstraint tc in _constraints)
                {
                    constraints.Add((SQLiteTableConstraint)tc.Clone());
                }
            }

            SQLiteObjectName tableName = null;

            if (this.ObjectName != null)
            {
                tableName = (SQLiteObjectName)this.ObjectName.Clone();
            }

            SQLiteCreateTableStatement res = new SQLiteCreateTableStatement(tableName);

            res._columns     = columns;
            res._constraints = constraints;
            res._ifNotExists = _ifNotExists;
            return(res);
        }
 public SQLiteCreateTableStatement(bool ifNotExists, SQLiteObjectName tableName)
     : base(tableName)
 {
     _ifNotExists = ifNotExists;
 }
Esempio n. 18
0
 private SQLiteCreateIndexStatement(SQLiteObjectName indexName)
     : base(indexName)
 {
 }
 public SQLiteSelectColumn(SQLiteObjectName tableName)
 {
     _tableName = tableName;
 }
Esempio n. 20
0
 public SQLiteInExpression(SQLiteExpression expr, bool isIn, SQLiteObjectName table)
 {
     _expr  = expr;
     _isIn  = isIn;
     _table = table;
 }
 private SQLiteCreateViewStatement(SQLiteObjectName viewName)
     : base(viewName)
 {
 }
 public SQLiteColumnStatement(SQLiteObjectName name)
     : base(name)
 {
 }
 private SQLiteCreateTableStatement(SQLiteObjectName tableName)
     : base(tableName)
 {
 }
 public SQLiteNameExpression(SQLiteObjectName name)
 {
     _name = name;
 }
Esempio n. 25
0
 public SQLiteDdlStatement(SQLiteObjectName name)
 {
     _objectName = name;
 }
 public SQLiteColumnStatement(SQLiteObjectName name, SQLiteColumnType type, List <SQLiteColumnConstraint> conslist)
     : base(name)
 {
     _type     = type;
     _conslist = conslist;
 }
 private SQLiteCreateTriggerStatement(SQLiteObjectName triggerName)
     : base(triggerName)
 {
 }
Esempio n. 28
0
 public SQLiteFromClause AddTable(SQLiteObjectName tableName, string asName,
                                  SQLiteFromIndexed indexed, SQLiteExpression onExpr, List <string> usingOpt)
 {
     _tables.Add(new SQLiteFromTable(tableName, asName, indexed, onExpr, usingOpt));
     return(this);
 }