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;
}
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);
}
public SQLiteFromTable(SQLiteObjectName table, string asName,
SQLiteFromIndexed indexed, SQLiteExpression onExpr, List <string> usingOpt)
{
_table = table;
AsName = asName;
_indexed = indexed;
_onExpr = onExpr;
_usingOpt = usingOpt;
}
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);
}
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);
}
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);
}
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()));
}
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);
}
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;
}
private SQLiteCreateIndexStatement(SQLiteObjectName indexName)
: base(indexName)
{
}
public SQLiteSelectColumn(SQLiteObjectName tableName)
{
_tableName = tableName;
}
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;
}
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)
{
}
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);
}
