You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1860 lines
57 KiB
1860 lines
57 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2003-2007 Jaroslaw Staniek <js@iidea.pl>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "kexidb/queryschema.h"
|
|
#include "kexidb/driver.h"
|
|
#include "kexidb/connection.h"
|
|
#include "kexidb/expression.h"
|
|
#include "kexidb/parser/sqlparser.h"
|
|
#include "utils.h"
|
|
#include "lookupfieldschema.h"
|
|
|
|
#include <assert.h>
|
|
|
|
#include <tqvaluelist.h>
|
|
#include <tqasciidict.h>
|
|
#include <tqptrdict.h>
|
|
#include <tqintdict.h>
|
|
#include <tqbitarray.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <tdelocale.h>
|
|
|
|
using namespace KexiDB;
|
|
|
|
QueryColumnInfo::QueryColumnInfo(Field *f, const TQCString& _alias, bool _visible,
|
|
QueryColumnInfo *foreignColumn)
|
|
: field(f), alias(_alias), visible(_visible), m_indexForVisibleLookupValue(-1)
|
|
, m_foreignColumn(foreignColumn)
|
|
{
|
|
}
|
|
|
|
QueryColumnInfo::~QueryColumnInfo()
|
|
{
|
|
}
|
|
|
|
TQString QueryColumnInfo::debugString() const
|
|
{
|
|
return field->name() +
|
|
( alias.isEmpty() ? TQString()
|
|
: (TQString::fromLatin1(" AS ") + TQString(alias)) );
|
|
}
|
|
|
|
//=======================================
|
|
namespace KexiDB {
|
|
//! @internal
|
|
class QuerySchemaPrivate
|
|
{
|
|
public:
|
|
QuerySchemaPrivate(QuerySchema* q, QuerySchemaPrivate* copy = 0)
|
|
: query(q)
|
|
, masterTable(0)
|
|
, fakeRowIDField(0)
|
|
, fakeRowIDCol(0)
|
|
, maxIndexWithAlias(-1)
|
|
, visibility(64)
|
|
, fieldsExpanded(0)
|
|
, internalFields(0)
|
|
, fieldsExpandedWithInternalAndRowID(0)
|
|
, fieldsExpandedWithInternal(0)
|
|
, autoincFields(0)
|
|
, columnsOrder(0)
|
|
, columnsOrderWithoutAsterisks(0)
|
|
, columnsOrderExpanded(0)
|
|
, pkeyFieldsOrder(0)
|
|
, pkeyFieldsCount(0)
|
|
, tablesBoundToColumns(64, -1)
|
|
, tablePositionsForAliases(67, false)
|
|
, columnPositionsForAliases(67, false)
|
|
, whereExpr(0)
|
|
, ownedVisibleColumns(0)
|
|
, regenerateExprAliases(false)
|
|
{
|
|
columnAliases.setAutoDelete(true);
|
|
tableAliases.setAutoDelete(true);
|
|
asterisks.setAutoDelete(true);
|
|
relations.setAutoDelete(true);
|
|
tablePositionsForAliases.setAutoDelete(true);
|
|
columnPositionsForAliases.setAutoDelete(true);
|
|
visibility.fill(false);
|
|
if (copy) {
|
|
// deep copy
|
|
*this = *copy;
|
|
if (copy->fieldsExpanded)
|
|
fieldsExpanded = new QueryColumnInfo::Vector(*copy->fieldsExpanded);
|
|
if (copy->internalFields)
|
|
internalFields = new QueryColumnInfo::Vector(*copy->internalFields);
|
|
if (copy->fieldsExpandedWithInternalAndRowID)
|
|
fieldsExpandedWithInternalAndRowID = new QueryColumnInfo::Vector(
|
|
*copy->fieldsExpandedWithInternalAndRowID);
|
|
if (copy->fieldsExpandedWithInternal)
|
|
fieldsExpandedWithInternal = new QueryColumnInfo::Vector(
|
|
*copy->fieldsExpandedWithInternal);
|
|
if (copy->autoincFields)
|
|
autoincFields = new QueryColumnInfo::List(*copy->autoincFields);
|
|
if (copy->columnsOrder)
|
|
columnsOrder = new TQMap<QueryColumnInfo*,int>(*copy->columnsOrder);
|
|
if (copy->columnsOrderWithoutAsterisks)
|
|
columnsOrderWithoutAsterisks = new TQMap<QueryColumnInfo*,int>(
|
|
*copy->columnsOrderWithoutAsterisks);
|
|
if (copy->columnsOrderExpanded)
|
|
columnsOrderExpanded = new TQMap<QueryColumnInfo*,int>(*copy->columnsOrderExpanded);
|
|
if (copy->pkeyFieldsOrder)
|
|
pkeyFieldsOrder = new TQValueVector<int>(*copy->pkeyFieldsOrder);
|
|
if (copy->whereExpr)
|
|
whereExpr = copy->whereExpr->copy();
|
|
if (copy->fakeRowIDCol)
|
|
fakeRowIDCol = new QueryColumnInfo(*copy->fakeRowIDCol);
|
|
if (copy->fakeRowIDField)
|
|
fakeRowIDField = new Field(*copy->fakeRowIDField);
|
|
if (copy->ownedVisibleColumns)
|
|
ownedVisibleColumns = new Field::List(*copy->ownedVisibleColumns);
|
|
}
|
|
}
|
|
~QuerySchemaPrivate()
|
|
{
|
|
delete fieldsExpanded;
|
|
delete internalFields;
|
|
delete fieldsExpandedWithInternalAndRowID;
|
|
delete fieldsExpandedWithInternal;
|
|
delete autoincFields;
|
|
delete columnsOrder;
|
|
delete columnsOrderWithoutAsterisks;
|
|
delete columnsOrderExpanded;
|
|
delete pkeyFieldsOrder;
|
|
delete whereExpr;
|
|
delete fakeRowIDCol;
|
|
delete fakeRowIDField;
|
|
delete ownedVisibleColumns;
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
columnAliases.clear();
|
|
tableAliases.clear();
|
|
asterisks.clear();
|
|
relations.clear();
|
|
masterTable = 0;
|
|
tables.clear();
|
|
clearCachedData();
|
|
delete pkeyFieldsOrder;
|
|
pkeyFieldsOrder=0;
|
|
visibility.fill(false);
|
|
tablesBoundToColumns = TQValueVector<int>(64,-1);
|
|
tablePositionsForAliases.clear();
|
|
columnPositionsForAliases.clear();
|
|
}
|
|
|
|
void clearCachedData()
|
|
{
|
|
orderByColumnList.clear();
|
|
if (fieldsExpanded) {
|
|
delete fieldsExpanded;
|
|
fieldsExpanded = 0;
|
|
delete internalFields;
|
|
internalFields = 0;
|
|
delete columnsOrder;
|
|
columnsOrder = 0;
|
|
delete columnsOrderWithoutAsterisks;
|
|
columnsOrderWithoutAsterisks = 0;
|
|
delete columnsOrderExpanded;
|
|
columnsOrderExpanded = 0;
|
|
delete autoincFields;
|
|
autoincFields = 0;
|
|
autoIncrementSQLFieldsList = TQString();
|
|
columnInfosByNameExpanded.clear();
|
|
columnInfosByName.clear();
|
|
delete ownedVisibleColumns;
|
|
ownedVisibleColumns = 0;
|
|
}
|
|
}
|
|
|
|
void setColumnAliasInternal(uint position, const TQCString& alias)
|
|
{
|
|
columnAliases.replace(position, new TQCString(alias));
|
|
columnPositionsForAliases.replace(alias, new int(position));
|
|
maxIndexWithAlias = TQMAX( maxIndexWithAlias, (int)position );
|
|
}
|
|
|
|
void setColumnAlias(uint position, const TQCString& alias)
|
|
{
|
|
TQCString *oldAlias = columnAliases.take(position);
|
|
if (oldAlias) {
|
|
tablePositionsForAliases.remove(*oldAlias);
|
|
delete oldAlias;
|
|
}
|
|
if (alias.isEmpty()) {
|
|
maxIndexWithAlias = -1;
|
|
}
|
|
else {
|
|
setColumnAliasInternal(position, alias);
|
|
}
|
|
}
|
|
|
|
bool hasColumnAliases()
|
|
{
|
|
tryRegenerateExprAliases();
|
|
return !columnAliases.isEmpty();
|
|
}
|
|
|
|
TQCString* columnAlias(uint position)
|
|
{
|
|
tryRegenerateExprAliases();
|
|
return columnAliases[position];
|
|
}
|
|
|
|
QuerySchema *query;
|
|
|
|
/*! Master table of the query. (may be NULL)
|
|
Any data modifications can be performed if we know master table.
|
|
If null, query's records cannot be modified. */
|
|
TableSchema *masterTable;
|
|
|
|
/*! List of tables used in this query */
|
|
TableSchema::List tables;
|
|
|
|
Field *fakeRowIDField; //! used to mark a place for ROWID
|
|
QueryColumnInfo *fakeRowIDCol; //! used to mark a place for ROWID
|
|
|
|
protected:
|
|
void tryRegenerateExprAliases()
|
|
{
|
|
if (!regenerateExprAliases)
|
|
return;
|
|
//regenerate missing aliases for experessions
|
|
Field *f;
|
|
uint p=0;
|
|
uint colNum=0; //used to generate a name
|
|
TQCString columnAlias;
|
|
for (Field::ListIterator it(query->fieldsIterator()); (f = it.current()); ++it, p++) {
|
|
if (f->isExpression() && !columnAliases[p]) {
|
|
//missing
|
|
for (;;) { //find 1st unused
|
|
colNum++;
|
|
columnAlias = (i18n("short for 'expression' word (only latin letters, please)", "expr")
|
|
+ TQString::number(colNum)).latin1();
|
|
if (!tablePositionsForAliases[columnAlias])
|
|
break;
|
|
}
|
|
setColumnAliasInternal(p, columnAlias);
|
|
}
|
|
}
|
|
regenerateExprAliases = false;
|
|
}
|
|
|
|
/*! Used to mapping columns to its aliases for this query */
|
|
TQIntDict<TQCString> columnAliases;
|
|
|
|
public:
|
|
/*! Used to mapping tables to its aliases for this query */
|
|
TQIntDict<TQCString> tableAliases;
|
|
|
|
/*! Helper used with aliases */
|
|
int maxIndexWithAlias;
|
|
|
|
/*! Helper used with tableAliases */
|
|
int maxIndexWithTableAlias;
|
|
|
|
/*! Used to store visibility flag for every field */
|
|
TQBitArray visibility;
|
|
|
|
/*! List of asterisks defined for this query */
|
|
Field::List asterisks;
|
|
|
|
/*! Temporary field vector for using in fieldsExpanded() */
|
|
// Field::Vector *fieldsExpanded;
|
|
QueryColumnInfo::Vector *fieldsExpanded;
|
|
|
|
/*! Temporary field vector containing internal fields used for lookup columns. */
|
|
QueryColumnInfo::Vector *internalFields;
|
|
|
|
/*! Temporary, used to cache sum of expanded fields and internal fields (+rowid) used for lookup columns.
|
|
Contains not auto-deleted items.*/
|
|
QueryColumnInfo::Vector *fieldsExpandedWithInternalAndRowID;
|
|
|
|
/*! Temporary, used to cache sum of expanded fields and internal fields used for lookup columns.
|
|
Contains not auto-deleted items.*/
|
|
QueryColumnInfo::Vector *fieldsExpandedWithInternal;
|
|
|
|
/*! A list of fields for ORDER BY section. @see QuerySchema::orderByColumnList(). */
|
|
OrderByColumnList orderByColumnList;
|
|
|
|
/*! A cache for autoIncrementFields(). */
|
|
QueryColumnInfo::List *autoincFields;
|
|
|
|
/*! A cache for autoIncrementSQLFieldsList(). */
|
|
TQString autoIncrementSQLFieldsList;
|
|
TQGuardedPtr<Driver> lastUsedDriverForAutoIncrementSQLFieldsList;
|
|
|
|
/*! A map for fast lookup of query columns' order (unexpanded version). */
|
|
TQMap<QueryColumnInfo*,int> *columnsOrder;
|
|
|
|
/*! A map for fast lookup of query columns' order (unexpanded version without asterisks). */
|
|
TQMap<QueryColumnInfo*,int> *columnsOrderWithoutAsterisks;
|
|
|
|
/*! A map for fast lookup of query columns' order.
|
|
This is exactly opposite information compared to vector returned
|
|
by fieldsExpanded() */
|
|
TQMap<QueryColumnInfo*,int> *columnsOrderExpanded;
|
|
|
|
// TQValueList<bool> detailedVisibility;
|
|
|
|
/*! order of PKEY fields (e.g. for updateRow() ) */
|
|
TQValueVector<int> *pkeyFieldsOrder;
|
|
|
|
/*! number of PKEY fields within the query */
|
|
uint pkeyFieldsCount;
|
|
|
|
/*! forced (predefined) statement */
|
|
TQString statement;
|
|
|
|
/*! Relationships defined for this query. */
|
|
Relationship::List relations;
|
|
|
|
/*! Information about columns bound to tables.
|
|
Used a table is used in FROM section more than once
|
|
(using table aliases).
|
|
|
|
This list is updated by insertField(uint position, Field *field,
|
|
int bindToTable, bool visible), using bindToTable parameter.
|
|
|
|
Example: for this statement:
|
|
SELECT t1.a, othertable.x, t2.b FROM table t1, table t2, othertable;
|
|
tablesBoundToColumns list looks like this:
|
|
[ 0, -1, 1 ]
|
|
- first column is bound to table 0 "t1"
|
|
- second coulmn is not specially bound (othertable.x isn't ambiguous)
|
|
- third column is bound to table 1 "t2"
|
|
*/
|
|
TQValueVector<int> tablesBoundToColumns;
|
|
|
|
/*! Collects table positions for aliases: used in tablePositionForAlias(). */
|
|
TQAsciiDict<int> tablePositionsForAliases;
|
|
|
|
/*! Collects column positions for aliases: used in columnPositionForAlias(). */
|
|
TQAsciiDict<int> columnPositionsForAliases;
|
|
|
|
/*! WHERE expression */
|
|
BaseExpr *whereExpr;
|
|
|
|
TQDict<QueryColumnInfo> columnInfosByNameExpanded;
|
|
|
|
TQDict<QueryColumnInfo> columnInfosByName; //!< Same as columnInfosByNameExpanded but asterisks are skipped
|
|
|
|
//! field schemas created for multiple joined columns like a||' '||b||' '||c
|
|
Field::List *ownedVisibleColumns;
|
|
|
|
/*! Set by insertField(): true, if aliases for expression columns should
|
|
be generated on next columnAlias() call. */
|
|
bool regenerateExprAliases : 1;
|
|
};
|
|
}
|
|
|
|
//=======================================
|
|
|
|
OrderByColumn::OrderByColumn()
|
|
: m_column(0)
|
|
, m_pos(-1)
|
|
, m_field(0)
|
|
, m_ascending(true)
|
|
{
|
|
}
|
|
|
|
OrderByColumn::OrderByColumn(QueryColumnInfo& column, bool ascending, int pos)
|
|
: m_column(&column)
|
|
, m_pos(pos)
|
|
, m_field(0)
|
|
, m_ascending(ascending)
|
|
{
|
|
}
|
|
|
|
OrderByColumn::OrderByColumn(Field& field, bool ascending)
|
|
: m_column(0)
|
|
, m_pos(-1)
|
|
, m_field(&field)
|
|
, m_ascending(ascending)
|
|
{
|
|
}
|
|
|
|
OrderByColumn::~OrderByColumn()
|
|
{
|
|
}
|
|
|
|
TQString OrderByColumn::debugString() const
|
|
{
|
|
TQString orderString( m_ascending ? "ascending" : "descending" );
|
|
if (m_column) {
|
|
if (m_pos>-1)
|
|
return TQString("COLUMN_AT_POSITION_%1(%2, %3)")
|
|
.arg(m_pos+1).arg(m_column->debugString()).arg(orderString);
|
|
else
|
|
return TQString("COLUMN(%1, %2)").arg(m_column->debugString()).arg(orderString);
|
|
}
|
|
return m_field ? TQString("FIELD(%1, %2)").arg(m_field->debugString()).arg(orderString)
|
|
: TQString("NONE");
|
|
}
|
|
|
|
TQString OrderByColumn::toSQLString(bool includeTableName, Driver *drv, int identifierEscaping) const
|
|
{
|
|
const TQString orderString( m_ascending ? "" : " DESC" );
|
|
TQString fieldName, tableName;
|
|
if (m_column) {
|
|
if (m_pos>-1)
|
|
return TQString::number(m_pos+1) + orderString;
|
|
else {
|
|
if (includeTableName && m_column->alias.isEmpty()) {
|
|
tableName = m_column->field->table()->name();
|
|
if (drv)
|
|
tableName = drv->escapeIdentifier(tableName, identifierEscaping);
|
|
tableName += ".";
|
|
}
|
|
fieldName = m_column->aliasOrName();
|
|
if (drv)
|
|
fieldName = drv->escapeIdentifier(fieldName, identifierEscaping);
|
|
}
|
|
}
|
|
else {
|
|
if (includeTableName) {
|
|
tableName = m_field->table()->name();
|
|
if (drv)
|
|
tableName = drv->escapeIdentifier(tableName, identifierEscaping);
|
|
tableName += ".";
|
|
}
|
|
fieldName = m_field ? m_field->name() : "??"/*error*/;
|
|
if (drv)
|
|
fieldName = drv->escapeIdentifier(fieldName, identifierEscaping);
|
|
}
|
|
return tableName + fieldName + orderString;
|
|
}
|
|
|
|
//=======================================
|
|
|
|
OrderByColumnList::OrderByColumnList()
|
|
: OrderByColumnListBase()
|
|
{
|
|
}
|
|
|
|
bool OrderByColumnList::appendFields(QuerySchema& querySchema,
|
|
const TQString& field1, bool ascending1,
|
|
const TQString& field2, bool ascending2,
|
|
const TQString& field3, bool ascending3,
|
|
const TQString& field4, bool ascending4,
|
|
const TQString& field5, bool ascending5)
|
|
{
|
|
uint numAdded = 0;
|
|
#define ADD_COL(fieldName, ascending) \
|
|
if (ok && !fieldName.isEmpty()) { \
|
|
if (!appendField( querySchema, fieldName, ascending )) \
|
|
ok = false; \
|
|
else \
|
|
numAdded++; \
|
|
}
|
|
bool ok = true;
|
|
ADD_COL(field1, ascending1);
|
|
ADD_COL(field2, ascending2);
|
|
ADD_COL(field3, ascending3);
|
|
ADD_COL(field4, ascending4);
|
|
ADD_COL(field5, ascending5);
|
|
#undef ADD_COL
|
|
if (ok)
|
|
return true;
|
|
for (uint i=0; i<numAdded; i++)
|
|
pop_back();
|
|
return false;
|
|
}
|
|
|
|
OrderByColumnList::~OrderByColumnList()
|
|
{
|
|
}
|
|
|
|
void OrderByColumnList::appendColumn(QueryColumnInfo& columnInfo, bool ascending)
|
|
{
|
|
appendColumn( OrderByColumn(columnInfo, ascending) );
|
|
}
|
|
|
|
bool OrderByColumnList::appendColumn(QuerySchema& querySchema, bool ascending, int pos)
|
|
{
|
|
QueryColumnInfo::Vector fieldsExpanded( querySchema.fieldsExpanded() );
|
|
QueryColumnInfo* ci = (pos >= (int)fieldsExpanded.size()) ? 0 : fieldsExpanded[pos];
|
|
if (!ci)
|
|
return false;
|
|
appendColumn( OrderByColumn(*ci, ascending, pos) );
|
|
return true;
|
|
}
|
|
|
|
void OrderByColumnList::appendField(Field& field, bool ascending)
|
|
{
|
|
appendColumn( OrderByColumn(field, ascending) );
|
|
}
|
|
|
|
bool OrderByColumnList::appendField(QuerySchema& querySchema,
|
|
const TQString& fieldName, bool ascending)
|
|
{
|
|
QueryColumnInfo *columnInfo = querySchema.columnInfo( fieldName );
|
|
if (columnInfo) {
|
|
appendColumn( OrderByColumn(*columnInfo, ascending) );
|
|
return true;
|
|
}
|
|
Field *field = querySchema.findTableField(fieldName);
|
|
if (field) {
|
|
appendColumn( OrderByColumn(*field, ascending) );
|
|
return true;
|
|
}
|
|
KexiDBWarn << "OrderByColumnList::addColumn(QuerySchema& querySchema, "
|
|
"const TQString& column, bool ascending): no such field \"" << fieldName << "\"" << endl;
|
|
return false;
|
|
}
|
|
|
|
void OrderByColumnList::appendColumn(const OrderByColumn& column)
|
|
{
|
|
append( column );
|
|
}
|
|
|
|
TQString OrderByColumnList::debugString() const
|
|
{
|
|
if (isEmpty())
|
|
return "NONE";
|
|
TQString dbg;
|
|
for (OrderByColumn::ListConstIterator it=constBegin(); it!=constEnd(); ++it) {
|
|
if (!dbg.isEmpty())
|
|
dbg += "\n";
|
|
dbg += (*it).debugString();
|
|
}
|
|
return dbg;
|
|
}
|
|
|
|
TQString OrderByColumnList::toSQLString(bool includeTableNames, Driver *drv, int identifierEscaping) const
|
|
{
|
|
TQString string;
|
|
for (OrderByColumn::ListConstIterator it=constBegin(); it!=constEnd(); ++it) {
|
|
if (!string.isEmpty())
|
|
string += ", ";
|
|
string += (*it).toSQLString(includeTableNames, drv, identifierEscaping);
|
|
}
|
|
return string;
|
|
}
|
|
|
|
//=======================================
|
|
|
|
QuerySchema::QuerySchema()
|
|
: FieldList(false)//fields are not owned by QuerySchema object
|
|
, SchemaData(KexiDB::QueryObjectType)
|
|
, d( new QuerySchemaPrivate(this) )
|
|
{
|
|
init();
|
|
}
|
|
|
|
QuerySchema::QuerySchema(TableSchema& tableSchema)
|
|
: FieldList(false)
|
|
, SchemaData(KexiDB::QueryObjectType)
|
|
, d( new QuerySchemaPrivate(this) )
|
|
{
|
|
d->masterTable = &tableSchema;
|
|
init();
|
|
/* if (!d->masterTable) {
|
|
KexiDBWarn << "QuerySchema(TableSchema*): !d->masterTable" << endl;
|
|
m_name = TQString();
|
|
return;
|
|
}*/
|
|
addTable(d->masterTable);
|
|
//defaults:
|
|
//inherit name from a table
|
|
m_name = d->masterTable->name();
|
|
//inherit caption from a table
|
|
m_caption = d->masterTable->caption();
|
|
|
|
//replaced by explicit field list: //add all fields of the table as asterisk:
|
|
//replaced by explicit field list: addField( new QueryAsterisk(this) );
|
|
|
|
// add explicit field list to avoid problems (e.g. with fields added outside of Kexi):
|
|
for (Field::ListIterator it( d->masterTable->fieldsIterator() ); it.current(); ++it) {
|
|
addField( it.current() );
|
|
}
|
|
}
|
|
|
|
QuerySchema::QuerySchema(const QuerySchema& querySchema)
|
|
: FieldList(querySchema, false /* !deepCopyFields */)
|
|
, SchemaData(querySchema)
|
|
, d( new QuerySchemaPrivate(this, querySchema.d) )
|
|
{
|
|
//only deep copy query asterisks
|
|
for (Field::ListIterator f_it(querySchema.m_fields); f_it.current(); ++f_it) {
|
|
Field *f;
|
|
if (dynamic_cast<QueryAsterisk*>( f_it.current() )) {
|
|
f = f_it.current()->copy();
|
|
if (static_cast<const KexiDB::FieldList *>(f_it.current()->m_parent) == &querySchema)
|
|
f->m_parent = this;
|
|
}
|
|
else
|
|
f = f_it.current();
|
|
addField( f );
|
|
}
|
|
}
|
|
|
|
QuerySchema::~QuerySchema()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
void QuerySchema::init()
|
|
{
|
|
m_type = KexiDB::QueryObjectType;
|
|
//m_fields_by_name.setAutoDelete( true ); //because we're using QueryColumnInfoEntry objects
|
|
}
|
|
|
|
void QuerySchema::clear()
|
|
{
|
|
FieldList::clear();
|
|
SchemaData::clear();
|
|
d->clear();
|
|
}
|
|
|
|
FieldList& QuerySchema::insertField(uint position, Field *field, bool visible)
|
|
{
|
|
return insertField(position, field, -1/*don't bind*/, visible);
|
|
}
|
|
|
|
/*virtual*/
|
|
FieldList& QuerySchema::insertField(uint position, Field *field)
|
|
{
|
|
return insertField( position, field, -1/*don't bind*/, true );
|
|
}
|
|
|
|
FieldList& QuerySchema::insertField(uint position, Field *field,
|
|
int bindToTable, bool visible)
|
|
{
|
|
if (!field) {
|
|
KexiDBWarn << "QuerySchema::insertField(): !field" << endl;
|
|
return *this;
|
|
}
|
|
|
|
if (position>m_fields.count()) {
|
|
KexiDBWarn << "QuerySchema::insertField(): position (" << position << ") out of range" << endl;
|
|
return *this;
|
|
}
|
|
if (!field->isQueryAsterisk() && !field->isExpression() && !field->table()) {
|
|
KexiDBWarn << "QuerySchema::insertField(): WARNING: field '"<<field->name()
|
|
<<"' must contain table information!" <<endl;
|
|
return *this;
|
|
}
|
|
if (fieldCount()>=d->visibility.size()) {
|
|
d->visibility.resize(d->visibility.size()*2);
|
|
d->tablesBoundToColumns.resize(d->tablesBoundToColumns.size()*2);
|
|
}
|
|
d->clearCachedData();
|
|
FieldList::insertField(position, field);
|
|
if (field->isQueryAsterisk()) {
|
|
d->asterisks.append(field);
|
|
//if this is single-table asterisk,
|
|
//add a table to list if doesn't exist there:
|
|
if (field->table() && (d->tables.findRef(field->table())==-1))
|
|
d->tables.append(field->table());
|
|
}
|
|
else if (field->table()) {
|
|
//add a table to list if doesn't exist there:
|
|
if (d->tables.findRef(field->table())==-1)
|
|
d->tables.append(field->table());
|
|
}
|
|
// //visible by default
|
|
// setFieldVisible(field, true);
|
|
// d->visibility.setBit(fieldCount()-1, visible);
|
|
//update visibility
|
|
//--move bits to make a place for a new one
|
|
for (uint i=fieldCount()-1; i>position; i--)
|
|
d->visibility.setBit(i, d->visibility.testBit(i-1));
|
|
d->visibility.setBit(position, visible);
|
|
|
|
//bind to table
|
|
if (bindToTable < -1 && bindToTable>(int)d->tables.count()) {
|
|
KexiDBWarn << "QuerySchema::insertField(): bindToTable (" << bindToTable
|
|
<< ") out of range" << endl;
|
|
bindToTable = -1;
|
|
}
|
|
//--move items to make a place for a new one
|
|
for (uint i=fieldCount()-1; i>position; i--)
|
|
d->tablesBoundToColumns[i] = d->tablesBoundToColumns[i-1];
|
|
d->tablesBoundToColumns[ position ] = bindToTable;
|
|
|
|
KexiDBDbg << "QuerySchema::insertField(): bound to table (" << bindToTable << "): " <<endl;
|
|
if (bindToTable==-1)
|
|
KexiDBDbg << " <NOT SPECIFIED>" << endl;
|
|
else
|
|
KexiDBDbg << " name=" << d->tables.at(bindToTable)->name()
|
|
<< " alias=" << tableAlias(bindToTable) << endl;
|
|
TQString s;
|
|
for (uint i=0; i<fieldCount();i++)
|
|
s+= (TQString::number(d->tablesBoundToColumns[i]) + " ");
|
|
KexiDBDbg << "tablesBoundToColumns == [" << s << "]" <<endl;
|
|
|
|
if (field->isExpression())
|
|
d->regenerateExprAliases = true;
|
|
|
|
return *this;
|
|
}
|
|
|
|
int QuerySchema::tableBoundToColumn(uint columnPosition) const
|
|
{
|
|
if (columnPosition > d->tablesBoundToColumns.count()) {
|
|
KexiDBWarn << "QuerySchema::tableBoundToColumn(): columnPosition (" << columnPosition
|
|
<< ") out of range" << endl;
|
|
return -1;
|
|
}
|
|
return d->tablesBoundToColumns[columnPosition];
|
|
}
|
|
|
|
KexiDB::FieldList& QuerySchema::addField(KexiDB::Field* field, bool visible)
|
|
{
|
|
return insertField(m_fields.count(), field, visible);
|
|
}
|
|
|
|
KexiDB::FieldList& QuerySchema::addField(KexiDB::Field* field, int bindToTable,
|
|
bool visible)
|
|
{
|
|
return insertField(m_fields.count(), field, bindToTable, visible);
|
|
}
|
|
|
|
void QuerySchema::removeField(KexiDB::Field *field)
|
|
{
|
|
if (!field)
|
|
return;
|
|
d->clearCachedData();
|
|
if (field->isQueryAsterisk()) {
|
|
d->asterisks.remove(field); //this will destroy this asterisk
|
|
}
|
|
//TODO: should we also remove table for this field or asterisk?
|
|
FieldList::removeField(field);
|
|
}
|
|
|
|
FieldList& QuerySchema::addExpression(BaseExpr* expr, bool visible)
|
|
{
|
|
return addField( new Field(this, expr), visible );
|
|
}
|
|
|
|
bool QuerySchema::isColumnVisible(uint position) const
|
|
{
|
|
return (position < fieldCount()) ? d->visibility.testBit(position) : false;
|
|
}
|
|
|
|
void QuerySchema::setColumnVisible(uint position, bool v)
|
|
{
|
|
if (position < fieldCount())
|
|
d->visibility.setBit(position, v);
|
|
}
|
|
|
|
FieldList& QuerySchema::addAsterisk(QueryAsterisk *asterisk, bool visible)
|
|
{
|
|
if (!asterisk)
|
|
return *this;
|
|
//make unique name
|
|
asterisk->m_name = (asterisk->table() ? asterisk->table()->name() + ".*" : "*")
|
|
+ TQString::number(asterisks()->count());
|
|
return addField(asterisk, visible);
|
|
}
|
|
|
|
Connection* QuerySchema::connection() const
|
|
{
|
|
TableSchema *mt = masterTable();
|
|
return mt ? mt->connection() : 0;
|
|
}
|
|
|
|
TQString QuerySchema::debugString()
|
|
{
|
|
TQString dbg;
|
|
dbg.reserve(1024);
|
|
//fields
|
|
TableSchema *mt = masterTable();
|
|
dbg = TQString("QUERY ") + schemaDataDebugString() + "\n"
|
|
+ "-masterTable=" + (mt ? mt->name() :"<NULL>")
|
|
+ "\n-COLUMNS:\n"
|
|
+ ((fieldCount()>0) ? FieldList::debugString() : "<NONE>") + "\n"
|
|
+ "-FIELDS EXPANDED ";
|
|
|
|
TQString dbg1;
|
|
uint fieldsExpandedCount = 0;
|
|
if (fieldCount()>0) {
|
|
QueryColumnInfo::Vector fe( fieldsExpanded() );
|
|
fieldsExpandedCount = fe.size();
|
|
for ( uint i=0; i < fieldsExpandedCount; i++ ) {
|
|
QueryColumnInfo *ci = fe[i];
|
|
if (!dbg1.isEmpty())
|
|
dbg1 += ",\n";
|
|
dbg1 += ci->debugString();
|
|
}
|
|
dbg1 += "\n";
|
|
}
|
|
else {
|
|
dbg1 = "<NONE>\n";
|
|
}
|
|
dbg1.prepend( TQString("(%1):\n").arg(fieldsExpandedCount) );
|
|
dbg += dbg1;
|
|
|
|
//it's safer to delete fieldsExpanded for now
|
|
// (debugString() could be called before all fields are added)
|
|
//causes a crash d->clearCachedData();
|
|
|
|
//bindings
|
|
TQString dbg2;
|
|
dbg2.reserve(512);
|
|
for (uint i = 0; i<fieldCount(); i++) {
|
|
int tablePos = tableBoundToColumn(i);
|
|
if (tablePos>=0) {
|
|
TQCString tAlias = tableAlias(tablePos);
|
|
if (!tAlias.isEmpty()) {
|
|
dbg2 += (TQString::fromLatin1(" field \"") + FieldList::field(i)->name()
|
|
+ "\" uses alias \"" + TQString(tAlias) + "\" of table \""
|
|
+ d->tables.at(tablePos)->name() + "\"\n");
|
|
}
|
|
}
|
|
}
|
|
if (!dbg2.isEmpty()) {
|
|
dbg += "\n-BINDINGS:\n";
|
|
dbg += dbg2;
|
|
}
|
|
|
|
//tables
|
|
TableSchema *table;
|
|
TQString table_names;
|
|
table_names.reserve(512);
|
|
for ( table = d->tables.first(); table; table = d->tables.next() ) {
|
|
if (!table_names.isEmpty())
|
|
table_names += ", ";
|
|
table_names += (TQString("'") + table->name() + "'");
|
|
}
|
|
if (d->tables.isEmpty())
|
|
table_names = "<NONE>";
|
|
dbg += (TQString("-TABLES:\n") + table_names);
|
|
TQString aliases;
|
|
if (!d->hasColumnAliases())
|
|
aliases = "<NONE>\n";
|
|
else {
|
|
Field::ListIterator it( m_fields );
|
|
for (int i=0; it.current(); ++it, i++) {
|
|
TQCString *alias = d->columnAlias(i);
|
|
if (alias)
|
|
aliases += (TQString("field #%1: ").arg(i)
|
|
+ (it.current()->name().isEmpty() ? "<noname>" : it.current()->name())
|
|
+ " -> " + (const char*)*alias + "\n");
|
|
}
|
|
}
|
|
//aliases
|
|
dbg += TQString("\n-COLUMN ALIASES:\n" + aliases);
|
|
if (d->tableAliases.isEmpty())
|
|
aliases = "<NONE>";
|
|
else {
|
|
aliases = "";
|
|
TableSchema::ListIterator t_it(d->tables);
|
|
for (int i=0; t_it.current(); ++t_it, i++) {
|
|
TQCString *alias = d->tableAliases[i];
|
|
if (alias)
|
|
aliases += (TQString("table #%1: ").arg(i)
|
|
+ (t_it.current()->name().isEmpty() ? "<noname>" : t_it.current()->name())
|
|
+ " -> " + (const char*)*alias + "\n");
|
|
}
|
|
}
|
|
dbg += TQString("-TABLE ALIASES:\n" + aliases);
|
|
TQString where = d->whereExpr ? d->whereExpr->debugString() : TQString();
|
|
if (!where.isEmpty())
|
|
dbg += (TQString("\n-WHERE EXPRESSION:\n") + where);
|
|
if (!orderByColumnList().isEmpty())
|
|
dbg += (TQString("\n-ORDER BY (%1):\n").arg(orderByColumnList().count())
|
|
+ orderByColumnList().debugString());
|
|
return dbg;
|
|
}
|
|
|
|
TableSchema* QuerySchema::masterTable() const
|
|
{
|
|
if (d->masterTable)
|
|
return d->masterTable;
|
|
if (d->tables.isEmpty())
|
|
return 0;
|
|
|
|
//try to find master table if there's only one table (with possible aliasses)
|
|
int num = 0;
|
|
TQString tableNameLower;
|
|
for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
|
|
if (!tableNameLower.isEmpty() && it.current()->name().lower()!=tableNameLower) {
|
|
//two or more different tables
|
|
return 0;
|
|
}
|
|
tableNameLower = tableAlias(num);
|
|
}
|
|
return d->tables.first();
|
|
}
|
|
|
|
void QuerySchema::setMasterTable(TableSchema *table)
|
|
{
|
|
if (table)
|
|
d->masterTable=table;
|
|
}
|
|
|
|
TableSchema::List* QuerySchema::tables() const
|
|
{
|
|
return &d->tables;
|
|
}
|
|
|
|
void QuerySchema::addTable(TableSchema *table, const TQCString& alias)
|
|
{
|
|
KexiDBDbg << "QuerySchema::addTable() " << (void *)table
|
|
<< " alias=" << alias << endl;
|
|
if (!table)
|
|
return;
|
|
|
|
//only append table if:
|
|
//-it has alias
|
|
//-it has no alias but there is no such table on the list
|
|
if (alias.isEmpty() && d->tables.findRef(table)!=-1) {
|
|
const TQString& tableNameLower = table->name().lower();
|
|
const TQString& aliasLower = TQString(alias.lower());
|
|
int num = 0;
|
|
for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
|
|
if (it.current()->name().lower()==tableNameLower) {
|
|
const TQString& tAlias = tableAlias(num);
|
|
if (tAlias == aliasLower) {
|
|
KexiDBWarn << "QuerySchema::addTable(): table with \""
|
|
<< tAlias << "\" alias already added!" << endl;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
d->tables.append(table);
|
|
|
|
if (!alias.isEmpty())
|
|
setTableAlias(d->tables.count()-1, alias);
|
|
}
|
|
|
|
void QuerySchema::removeTable(TableSchema *table)
|
|
{
|
|
if (!table)
|
|
return;
|
|
if (d->masterTable == table)
|
|
d->masterTable = 0;
|
|
d->tables.remove(table);
|
|
//todo: remove fields!
|
|
}
|
|
|
|
TableSchema* QuerySchema::table(const TQString& tableName) const
|
|
{
|
|
//TODO: maybe use tables_byname?
|
|
for (TableSchema::ListIterator it(d->tables); it.current(); ++it) {
|
|
if (it.current()->name().lower()==tableName.lower())
|
|
return it.current();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool QuerySchema::contains(TableSchema *table) const
|
|
{
|
|
return d->tables.findRef(table)!=-1;
|
|
}
|
|
|
|
Field* QuerySchema::findTableField(const TQString &tableOrTableAndFieldName) const
|
|
{
|
|
TQString tableName, fieldName;
|
|
if (!KexiDB::splitToTableAndFieldParts(tableOrTableAndFieldName,
|
|
tableName, fieldName, KexiDB::SetFieldNameIfNoTableName)) {
|
|
return 0;
|
|
}
|
|
if (tableName.isEmpty()) {
|
|
for (TableSchema::ListIterator it(d->tables); it.current(); ++it) {
|
|
if (it.current()->field(fieldName))
|
|
return it.current()->field(fieldName);
|
|
}
|
|
return 0;
|
|
}
|
|
TableSchema *tableSchema = table(tableName);
|
|
if (!tableSchema)
|
|
return 0;
|
|
return tableSchema->field(fieldName);
|
|
}
|
|
|
|
TQCString QuerySchema::columnAlias(uint position) const
|
|
{
|
|
TQCString *a = d->columnAlias(position);
|
|
return a ? *a : TQCString();
|
|
}
|
|
|
|
bool QuerySchema::hasColumnAlias(uint position) const
|
|
{
|
|
return d->columnAlias(position)!=0;
|
|
}
|
|
|
|
void QuerySchema::setColumnAlias(uint position, const TQCString& alias)
|
|
{
|
|
if (position >= m_fields.count()) {
|
|
KexiDBWarn << "QuerySchema::setColumnAlias(): position (" << position
|
|
<< ") out of range!" << endl;
|
|
return;
|
|
}
|
|
TQCString fixedAlias = alias.stripWhiteSpace();
|
|
Field *f = FieldList::field(position);
|
|
if (f->captionOrName().isEmpty() && fixedAlias.isEmpty()) {
|
|
KexiDBWarn << "QuerySchema::setColumnAlias(): position (" << position
|
|
<< ") could not remove alias when no name is specified for expression column!" << endl;
|
|
return;
|
|
}
|
|
d->setColumnAlias(position, fixedAlias);
|
|
}
|
|
|
|
TQCString QuerySchema::tableAlias(uint position) const
|
|
{
|
|
TQCString *a = d->tableAliases[position];
|
|
return a ? *a : TQCString();
|
|
}
|
|
|
|
int QuerySchema::tablePositionForAlias(const TQCString& name) const
|
|
{
|
|
int *num = d->tablePositionsForAliases[name];
|
|
if (!num)
|
|
return -1;
|
|
return *num;
|
|
}
|
|
|
|
int QuerySchema::tablePosition(const TQString& tableName) const
|
|
{
|
|
int num = 0;
|
|
for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
|
|
if (it.current()->name().lower()==tableName.lower())
|
|
return num;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
TQValueList<int> QuerySchema::tablePositions(const TQString& tableName) const
|
|
{
|
|
int num = 0;
|
|
TQValueList<int> result;
|
|
const TQString& tableNameLower = tableName.lower();
|
|
for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
|
|
if (it.current()->name().lower()==tableNameLower) {
|
|
result += num;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool QuerySchema::hasTableAlias(uint position) const
|
|
{
|
|
return d->tableAliases[position]!=0;
|
|
}
|
|
|
|
int QuerySchema::columnPositionForAlias(const TQCString& name) const
|
|
{
|
|
int *num = d->columnPositionsForAliases[name];
|
|
if (!num)
|
|
return -1;
|
|
return *num;
|
|
}
|
|
|
|
void QuerySchema::setTableAlias(uint position, const TQCString& alias)
|
|
{
|
|
if (position >= d->tables.count()) {
|
|
KexiDBWarn << "QuerySchema::setTableAlias(): position (" << position
|
|
<< ") out of range!" << endl;
|
|
return;
|
|
}
|
|
TQCString fixedAlias = alias.stripWhiteSpace();
|
|
if (fixedAlias.isEmpty()) {
|
|
TQCString *oldAlias = d->tableAliases.take(position);
|
|
if (oldAlias) {
|
|
d->tablePositionsForAliases.remove(*oldAlias);
|
|
delete oldAlias;
|
|
}
|
|
// d->maxIndexWithTableAlias = -1;
|
|
}
|
|
else {
|
|
d->tableAliases.replace(position, new TQCString(fixedAlias));
|
|
d->tablePositionsForAliases.replace(fixedAlias, new int(position));
|
|
// d->maxIndexWithTableAlias = TQMAX( d->maxIndexWithTableAlias, (int)index );
|
|
}
|
|
}
|
|
|
|
Relationship::List* QuerySchema::relationships() const
|
|
{
|
|
return &d->relations;
|
|
}
|
|
|
|
Field::List* QuerySchema::asterisks() const
|
|
{
|
|
return &d->asterisks;
|
|
}
|
|
|
|
TQString QuerySchema::statement() const
|
|
{
|
|
return d->statement;
|
|
}
|
|
|
|
void QuerySchema::setStatement(const TQString &s)
|
|
{
|
|
d->statement = s;
|
|
}
|
|
|
|
Field* QuerySchema::field(const TQString& identifier, bool expanded)
|
|
{
|
|
QueryColumnInfo *ci = columnInfo(identifier, expanded);
|
|
return ci ? ci->field : 0;
|
|
}
|
|
|
|
QueryColumnInfo* QuerySchema::columnInfo(const TQString& identifier, bool expanded)
|
|
{
|
|
computeFieldsExpanded();
|
|
return expanded ? d->columnInfosByNameExpanded[identifier] : d->columnInfosByName[identifier];
|
|
}
|
|
|
|
QueryColumnInfo::Vector QuerySchema::fieldsExpanded(FieldsExpandedOptions options)
|
|
{
|
|
computeFieldsExpanded();
|
|
if (options == WithInternalFields || options == WithInternalFieldsAndRowID) {
|
|
//a ref to a proper pointer (as we cache the vector for two cases)
|
|
QueryColumnInfo::Vector*& tmpFieldsExpandedWithInternal =
|
|
(options == WithInternalFields) ? d->fieldsExpandedWithInternal : d->fieldsExpandedWithInternalAndRowID;
|
|
//special case
|
|
if (!tmpFieldsExpandedWithInternal) {
|
|
//glue expanded and internal fields and cache it
|
|
const uint size = d->fieldsExpanded->count()
|
|
+ (d->internalFields ? d->internalFields->count() : 0)
|
|
+ ((options == WithInternalFieldsAndRowID) ? 1 : 0) /*ROWID*/;
|
|
tmpFieldsExpandedWithInternal = new QueryColumnInfo::Vector( size );
|
|
const uint fieldsExpandedVectorSize = d->fieldsExpanded->size();
|
|
for (uint i=0; i<fieldsExpandedVectorSize; i++)
|
|
tmpFieldsExpandedWithInternal->insert(i, d->fieldsExpanded->at(i));
|
|
const uint internalFieldsCount = d->internalFields ? d->internalFields->size() : 0;
|
|
if (internalFieldsCount > 0) {
|
|
for (uint i=0; i < internalFieldsCount; i++)
|
|
tmpFieldsExpandedWithInternal->insert(
|
|
fieldsExpandedVectorSize + i, d->internalFields->at(i));
|
|
}
|
|
if (options == WithInternalFieldsAndRowID) {
|
|
if (!d->fakeRowIDField) {
|
|
d->fakeRowIDField = new Field("rowID", Field::BigInteger);
|
|
d->fakeRowIDCol = new QueryColumnInfo(d->fakeRowIDField, TQCString(), true);
|
|
}
|
|
tmpFieldsExpandedWithInternal->insert(
|
|
fieldsExpandedVectorSize + internalFieldsCount, d->fakeRowIDCol );
|
|
}
|
|
}
|
|
return *tmpFieldsExpandedWithInternal;
|
|
}
|
|
|
|
if (options == Default)
|
|
return *d->fieldsExpanded;
|
|
|
|
//options == Unique:
|
|
TQDict<char> columnsAlreadyFound;
|
|
QueryColumnInfo::Vector result( d->fieldsExpanded->count() ); //initial size is set
|
|
// TQMapConstIterator<QueryColumnInfo*, bool> columnsAlreadyFoundIt;
|
|
//compute unique list
|
|
uint uniqueListCount = 0;
|
|
for (uint i=0; i<d->fieldsExpanded->count(); i++) {
|
|
QueryColumnInfo *ci = (*d->fieldsExpanded)[i];
|
|
// columnsAlreadyFoundIt = columnsAlreadyFound.find(ci);
|
|
// uint foundColumnIndex = -1;
|
|
if (!columnsAlreadyFound[ci->aliasOrName()]) {// columnsAlreadyFoundIt==columnsAlreadyFound.constEnd())
|
|
columnsAlreadyFound.insert(ci->aliasOrName(), (char*)1);
|
|
result.insert(uniqueListCount++, ci);
|
|
}
|
|
}
|
|
result.resize(uniqueListCount); //update result size
|
|
return result;
|
|
}
|
|
|
|
QueryColumnInfo::Vector QuerySchema::internalFields()
|
|
{
|
|
computeFieldsExpanded();
|
|
return d->internalFields ? *d->internalFields : QueryColumnInfo::Vector();
|
|
}
|
|
|
|
QueryColumnInfo* QuerySchema::expandedOrInternalField(uint index)
|
|
{
|
|
QueryColumnInfo::Vector vector = fieldsExpanded(WithInternalFields);
|
|
return (index < vector.size()) ? vector[index] : 0;
|
|
}
|
|
|
|
inline TQString lookupColumnKey(Field *foreignField, Field* field)
|
|
{
|
|
TQString res;
|
|
if (field->table()) // can be 0 for anonymous fields built as joined multiple visible columns
|
|
res = field->table()->name() + ".";
|
|
return res + field->name() + "_" + foreignField->table()->name() + "." + foreignField->name();
|
|
}
|
|
|
|
void QuerySchema::computeFieldsExpanded()
|
|
{
|
|
if (d->fieldsExpanded)
|
|
return;
|
|
|
|
if (!d->columnsOrder) {
|
|
d->columnsOrder = new TQMap<QueryColumnInfo*,int>();
|
|
d->columnsOrderWithoutAsterisks = new TQMap<QueryColumnInfo*,int>();
|
|
}
|
|
else {
|
|
d->columnsOrder->clear();
|
|
d->columnsOrderWithoutAsterisks->clear();
|
|
}
|
|
if (d->ownedVisibleColumns)
|
|
d->ownedVisibleColumns->clear();
|
|
|
|
//collect all fields in a list (not a vector yet, because we do not know its size)
|
|
QueryColumnInfo::List list; //temporary
|
|
QueryColumnInfo::List lookup_list; //temporary, for collecting additional fields related to lookup fields
|
|
TQMap<QueryColumnInfo*, bool> columnInfosOutsideAsterisks; //helper for filling d->columnInfosByName
|
|
uint i = 0;
|
|
uint fieldPosition = 0;
|
|
uint numberOfColumnsWithMultipleVisibleFields = 0; //used to find an unique name for anonymous field
|
|
Field *f;
|
|
for (Field::ListIterator it = fieldsIterator(); (f = it.current()); ++it, fieldPosition++) {
|
|
if (f->isQueryAsterisk()) {
|
|
if (static_cast<QueryAsterisk*>(f)->isSingleTableAsterisk()) {
|
|
Field::List *ast_fields = static_cast<QueryAsterisk*>(f)->table()->fields();
|
|
for (Field *ast_f = ast_fields->first(); ast_f; ast_f=ast_fields->next()) {
|
|
// d->detailedVisibility += isFieldVisible(fieldPosition);
|
|
QueryColumnInfo *ci = new QueryColumnInfo(ast_f, TQCString()/*no field for asterisk!*/,
|
|
isColumnVisible(fieldPosition));
|
|
list.append( ci );
|
|
KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) columns order: "
|
|
<< ci->debugString() << " at position " << fieldPosition << endl;
|
|
d->columnsOrder->insert(ci, fieldPosition);
|
|
// list.append(ast_f);
|
|
}
|
|
}
|
|
else {//all-tables asterisk: iterate through table list
|
|
for (TableSchema *table = d->tables.first(); table; table = d->tables.next()) {
|
|
//add all fields from this table
|
|
Field::List *tab_fields = table->fields();
|
|
for (Field *tab_f = tab_fields->first(); tab_f; tab_f = tab_fields->next()) {
|
|
//! \todo (js): perhaps not all fields should be appended here
|
|
// d->detailedVisibility += isFieldVisible(fieldPosition);
|
|
// list.append(tab_f);
|
|
QueryColumnInfo *ci = new QueryColumnInfo(tab_f, TQCString()/*no field for asterisk!*/,
|
|
isColumnVisible(fieldPosition));
|
|
list.append( ci );
|
|
KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) columns order: "
|
|
<< ci->debugString() << " at position " << fieldPosition << endl;
|
|
d->columnsOrder->insert(ci, fieldPosition);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
//a single field
|
|
// d->detailedVisibility += isFieldVisible(fieldPosition);
|
|
QueryColumnInfo *ci = new QueryColumnInfo(f, columnAlias(fieldPosition), isColumnVisible(fieldPosition));
|
|
list.append( ci );
|
|
columnInfosOutsideAsterisks.insert( ci, true );
|
|
KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) column's order: "
|
|
<< ci->debugString() << " at position " << fieldPosition << endl;
|
|
d->columnsOrder->insert(ci, fieldPosition);
|
|
d->columnsOrderWithoutAsterisks->insert(ci, fieldPosition);
|
|
|
|
//handle lookup field schema
|
|
LookupFieldSchema *lookupFieldSchema = f->table() ? f->table()->lookupFieldSchema( *f ) : 0;
|
|
if (!lookupFieldSchema || lookupFieldSchema->boundColumn()<0)
|
|
continue;
|
|
// Lookup field schema found:
|
|
// Now we also need to fetch "visible" value from the lookup table, not only the value of binding.
|
|
// -> build LEFT OUTER JOIN clause for this purpose (LEFT, not INNER because the binding can be broken)
|
|
// "LEFT OUTER JOIN lookupTable ON thisTable.thisField=lookupTable.boundField"
|
|
LookupFieldSchema::RowSource& rowSource = lookupFieldSchema->rowSource();
|
|
if (rowSource.type() == LookupFieldSchema::RowSource::Table) {
|
|
TableSchema *lookupTable = connection()->tableSchema( rowSource.name() );
|
|
FieldList* visibleColumns = 0;
|
|
Field *boundField = 0;
|
|
if (lookupTable
|
|
&& (uint)lookupFieldSchema->boundColumn() < lookupTable->fieldCount()
|
|
&& (visibleColumns = lookupTable->subList( lookupFieldSchema->visibleColumns() ))
|
|
&& (boundField = lookupTable->field( lookupFieldSchema->boundColumn() )))
|
|
{
|
|
Field *visibleColumn = 0;
|
|
// for single visible column, just add it as-is
|
|
if (visibleColumns->fieldCount() == 1) {
|
|
visibleColumn = visibleColumns->fields()->first();
|
|
}
|
|
else {
|
|
// for multiple visible columns, build an expression column
|
|
// (the expression object will be owned by column info)
|
|
visibleColumn = new Field();
|
|
visibleColumn->setName(
|
|
TQString::fromLatin1("[multiple_visible_fields_%1]")
|
|
.arg( ++numberOfColumnsWithMultipleVisibleFields ));
|
|
visibleColumn->setExpression(
|
|
new ConstExpr(CHARACTER_STRING_LITERAL, TQVariant()/*not important*/));
|
|
if (!d->ownedVisibleColumns) {
|
|
d->ownedVisibleColumns = new Field::List();
|
|
d->ownedVisibleColumns->setAutoDelete(true);
|
|
}
|
|
d->ownedVisibleColumns->append( visibleColumn ); // remember to delete later
|
|
}
|
|
|
|
lookup_list.append(
|
|
new QueryColumnInfo(visibleColumn, TQCString(), true/*visible*/, ci/*foreign*/) );
|
|
/*
|
|
//add visibleField to the list of SELECTed fields if it is not yes present there
|
|
if (!findTableField( visibleField->table()->name()+"."+visibleField->name() )) {
|
|
if (!table( visibleField->table()->name() )) {
|
|
}
|
|
if (!sql.isEmpty())
|
|
sql += TQString::fromLatin1(", ");
|
|
sql += (escapeIdentifier(visibleField->table()->name(), drvEscaping) + "."
|
|
+ escapeIdentifier(visibleField->name(), drvEscaping));
|
|
}*/
|
|
}
|
|
delete visibleColumns;
|
|
}
|
|
else if (rowSource.type() == LookupFieldSchema::RowSource::Query) {
|
|
QuerySchema *lookupQuery = connection()->querySchema( rowSource.name() );
|
|
if (!lookupQuery)
|
|
continue;
|
|
const QueryColumnInfo::Vector lookupQueryFieldsExpanded( lookupQuery->fieldsExpanded() );
|
|
if ((uint)lookupFieldSchema->boundColumn() >= lookupQueryFieldsExpanded.count())
|
|
continue;
|
|
QueryColumnInfo *boundColumnInfo = 0;
|
|
if (!(boundColumnInfo = lookupQueryFieldsExpanded[ lookupFieldSchema->boundColumn() ]))
|
|
continue;
|
|
Field *boundField = boundColumnInfo->field;
|
|
if (!boundField)
|
|
continue;
|
|
const TQValueList<uint> visibleColumns( lookupFieldSchema->visibleColumns() );
|
|
bool ok = true;
|
|
// all indices in visibleColumns should be in [0..lookupQueryFieldsExpanded.size()-1]
|
|
foreach (TQValueList<uint>::ConstIterator, visibleColumnsIt, visibleColumns) {
|
|
if ((*visibleColumnsIt) >= lookupQueryFieldsExpanded.count()) {
|
|
ok = false;
|
|
break;
|
|
}
|
|
}
|
|
if (!ok)
|
|
continue;
|
|
Field *visibleColumn = 0;
|
|
// for single visible column, just add it as-is
|
|
if (visibleColumns.count() == 1) {
|
|
visibleColumn = lookupQueryFieldsExpanded[ visibleColumns.first() ]->field;
|
|
}
|
|
else {
|
|
// for multiple visible columns, build an expression column
|
|
// (the expression object will be owned by column info)
|
|
visibleColumn = new Field();
|
|
visibleColumn->setName(
|
|
TQString::fromLatin1("[multiple_visible_fields_%1]")
|
|
.arg( ++numberOfColumnsWithMultipleVisibleFields ));
|
|
visibleColumn->setExpression(
|
|
new ConstExpr(CHARACTER_STRING_LITERAL, TQVariant()/*not important*/));
|
|
if (!d->ownedVisibleColumns) {
|
|
d->ownedVisibleColumns = new Field::List();
|
|
d->ownedVisibleColumns->setAutoDelete(true);
|
|
}
|
|
d->ownedVisibleColumns->append( visibleColumn ); // remember to delete later
|
|
}
|
|
|
|
lookup_list.append(
|
|
new QueryColumnInfo(visibleColumn, TQCString(), true/*visible*/, ci/*foreign*/) );
|
|
/*
|
|
//add visibleField to the list of SELECTed fields if it is not yes present there
|
|
if (!findTableField( visibleField->table()->name()+"."+visibleField->name() )) {
|
|
if (!table( visibleField->table()->name() )) {
|
|
}
|
|
if (!sql.isEmpty())
|
|
sql += TQString::fromLatin1(", ");
|
|
sql += (escapeIdentifier(visibleField->table()->name(), drvEscaping) + "."
|
|
+ escapeIdentifier(visibleField->name(), drvEscaping));
|
|
}*/
|
|
}
|
|
}
|
|
}
|
|
//prepare clean vector for expanded list, and a map for order information
|
|
if (!d->fieldsExpanded) {
|
|
d->fieldsExpanded = new QueryColumnInfo::Vector( list.count() );// Field::Vector( list.count() );
|
|
d->fieldsExpanded->setAutoDelete(true);
|
|
d->columnsOrderExpanded = new TQMap<QueryColumnInfo*,int>();
|
|
}
|
|
else {//for future:
|
|
d->fieldsExpanded->clear();
|
|
d->fieldsExpanded->resize( list.count() );
|
|
d->columnsOrderExpanded->clear();
|
|
}
|
|
|
|
/*fill (based on prepared 'list' and 'lookup_list'):
|
|
-the vector
|
|
-the map
|
|
-"fields by name" dictionary
|
|
*/
|
|
d->columnInfosByName.clear();
|
|
d->columnInfosByNameExpanded.clear();
|
|
i=0;
|
|
QueryColumnInfo *ci;
|
|
for (QueryColumnInfo::ListIterator it(list); (ci = it.current()); ++it, i++) {
|
|
d->fieldsExpanded->insert(i, ci);
|
|
d->columnsOrderExpanded->insert(ci, i);
|
|
//remember field by name/alias/table.name if there's no such string yet in d->columnInfosByNameExpanded
|
|
if (!ci->alias.isEmpty()) {
|
|
//store alias and table.alias
|
|
if (!d->columnInfosByNameExpanded[ ci->alias ])
|
|
d->columnInfosByNameExpanded.insert( ci->alias, ci );
|
|
TQString tableAndAlias( ci->alias );
|
|
if (ci->field->table())
|
|
tableAndAlias.prepend(ci->field->table()->name() + ".");
|
|
if (!d->columnInfosByNameExpanded[ tableAndAlias ])
|
|
d->columnInfosByNameExpanded.insert( tableAndAlias, ci );
|
|
//the same for "unexpanded" list
|
|
if (columnInfosOutsideAsterisks.contains(ci)) {
|
|
if (!d->columnInfosByName[ ci->alias ])
|
|
d->columnInfosByName.insert( ci->alias, ci );
|
|
if (!d->columnInfosByName[ tableAndAlias ])
|
|
d->columnInfosByName.insert( tableAndAlias, ci );
|
|
}
|
|
}
|
|
else {
|
|
//no alias: store name and table.name
|
|
if (!d->columnInfosByNameExpanded[ ci->field->name() ])
|
|
d->columnInfosByNameExpanded.insert( ci->field->name(), ci );
|
|
TQString tableAndName( ci->field->name() );
|
|
if (ci->field->table())
|
|
tableAndName.prepend(ci->field->table()->name() + ".");
|
|
if (!d->columnInfosByNameExpanded[ tableAndName ])
|
|
d->columnInfosByNameExpanded.insert( tableAndName, ci );
|
|
//the same for "unexpanded" list
|
|
if (columnInfosOutsideAsterisks.contains(ci)) {
|
|
if (!d->columnInfosByName[ ci->field->name() ])
|
|
d->columnInfosByName.insert( ci->field->name(), ci );
|
|
if (!d->columnInfosByName[ tableAndName ])
|
|
d->columnInfosByName.insert( tableAndName, ci );
|
|
}
|
|
}
|
|
}
|
|
|
|
//remove duplicates for lookup fields
|
|
TQDict<uint> lookup_dict(1009); //used to fight duplicates and to update QueryColumnInfo::indexForVisibleLookupValue()
|
|
// (a mapping from table.name string to uint* lookupFieldIndex
|
|
lookup_dict.setAutoDelete(true);
|
|
i=0;
|
|
for (QueryColumnInfo::ListIterator it(lookup_list); (ci = it.current());)
|
|
{
|
|
const TQString key( lookupColumnKey(ci->foreignColumn()->field, ci->field) );
|
|
if ( /* not needed columnInfo( tableAndFieldName ) || */
|
|
lookup_dict[ key ]) {
|
|
// this table.field is already fetched by this query
|
|
++it;
|
|
lookup_list.removeRef( ci );
|
|
}
|
|
else {
|
|
lookup_dict.replace( key, new uint( i ) );
|
|
++it;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
//create internal expanded list with lookup fields
|
|
if (d->internalFields) {
|
|
d->internalFields->clear();
|
|
d->internalFields->resize( lookup_list.count() );
|
|
}
|
|
delete d->fieldsExpandedWithInternal; //clear cache
|
|
delete d->fieldsExpandedWithInternalAndRowID; //clear cache
|
|
d->fieldsExpandedWithInternal = 0;
|
|
d->fieldsExpandedWithInternalAndRowID = 0;
|
|
if (!lookup_list.isEmpty() && !d->internalFields) {//create on demand
|
|
d->internalFields = new QueryColumnInfo::Vector( lookup_list.count() );
|
|
d->internalFields->setAutoDelete(true);
|
|
}
|
|
i=0;
|
|
for (QueryColumnInfo::ListIterator it(lookup_list); it.current();i++, ++it)
|
|
{
|
|
//add it to the internal list
|
|
d->internalFields->insert(i, it.current());
|
|
d->columnsOrderExpanded->insert(it.current(), list.count()+i);
|
|
}
|
|
|
|
//update QueryColumnInfo::indexForVisibleLookupValue() cache for columns
|
|
numberOfColumnsWithMultipleVisibleFields = 0;
|
|
for (i=0; i < d->fieldsExpanded->size(); i++) {
|
|
QueryColumnInfo* ci = d->fieldsExpanded->at(i);
|
|
//! @todo QuerySchema itself will also support lookup fields...
|
|
LookupFieldSchema *lookupFieldSchema
|
|
= ci->field->table() ? ci->field->table()->lookupFieldSchema( *ci->field ) : 0;
|
|
if (!lookupFieldSchema || lookupFieldSchema->boundColumn()<0)
|
|
continue;
|
|
LookupFieldSchema::RowSource& rowSource = lookupFieldSchema->rowSource();
|
|
if (rowSource.type() == LookupFieldSchema::RowSource::Table) {
|
|
TableSchema *lookupTable = connection()->tableSchema( rowSource.name() );
|
|
FieldList* visibleColumns = 0;
|
|
if (lookupTable
|
|
&& (uint)lookupFieldSchema->boundColumn() < lookupTable->fieldCount()
|
|
&& (visibleColumns = lookupTable->subList( lookupFieldSchema->visibleColumns() )))
|
|
{
|
|
Field *visibleColumn = 0;
|
|
// for single visible column, just add it as-is
|
|
if (visibleColumns->fieldCount() == 1)
|
|
{
|
|
visibleColumn = visibleColumns->fields()->first();
|
|
const TQString key( lookupColumnKey(ci->field, visibleColumn) );
|
|
uint *index = lookup_dict[ key ];
|
|
if (index)
|
|
ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
|
|
}
|
|
else {
|
|
const TQString key( TQString::fromLatin1("[multiple_visible_fields_%1]_%2.%3")
|
|
.arg( ++numberOfColumnsWithMultipleVisibleFields )
|
|
.arg(ci->field->table()->name()).arg(ci->field->name()) );
|
|
uint *index = lookup_dict[ key ];
|
|
if (index)
|
|
ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
|
|
}
|
|
}
|
|
delete visibleColumns;
|
|
}
|
|
else if (rowSource.type() == LookupFieldSchema::RowSource::Query) {
|
|
QuerySchema *lookupQuery = connection()->querySchema( rowSource.name() );
|
|
if (!lookupQuery)
|
|
continue;
|
|
const QueryColumnInfo::Vector lookupQueryFieldsExpanded( lookupQuery->fieldsExpanded() );
|
|
if ((uint)lookupFieldSchema->boundColumn() >= lookupQueryFieldsExpanded.count())
|
|
continue;
|
|
QueryColumnInfo *boundColumnInfo = 0;
|
|
if (!(boundColumnInfo = lookupQueryFieldsExpanded[ lookupFieldSchema->boundColumn() ]))
|
|
continue;
|
|
Field *boundField = boundColumnInfo->field;
|
|
if (!boundField)
|
|
continue;
|
|
const TQValueList<uint> visibleColumns( lookupFieldSchema->visibleColumns() );
|
|
Field *visibleColumn = 0;
|
|
// for single visible column, just add it as-is
|
|
if (visibleColumns.count() == 1) {
|
|
visibleColumn = lookupQueryFieldsExpanded[ visibleColumns.first() ]->field;
|
|
const TQString key( lookupColumnKey(ci->field, visibleColumn) );
|
|
uint *index = lookup_dict[ key ];
|
|
if (index)
|
|
ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
|
|
}
|
|
else {
|
|
const TQString key( TQString::fromLatin1("[multiple_visible_fields_%1]_%2.%3")
|
|
.arg( ++numberOfColumnsWithMultipleVisibleFields )
|
|
.arg(ci->field->table()->name()).arg(ci->field->name()) );
|
|
uint *index = lookup_dict[ key ];
|
|
if (index)
|
|
ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
|
|
}
|
|
}
|
|
else {
|
|
KexiDBWarn << "QuerySchema::computeFieldsExpanded(): unsupported row source type "
|
|
<< rowSource.typeName() << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
TQMap<QueryColumnInfo*,int> QuerySchema::columnsOrder(ColumnsOrderOptions options)
|
|
{
|
|
if (!d->columnsOrder)
|
|
computeFieldsExpanded();
|
|
if (options == UnexpandedList)
|
|
return *d->columnsOrder;
|
|
else if (options == UnexpandedListWithoutAsterisks)
|
|
return *d->columnsOrderWithoutAsterisks;
|
|
return *d->columnsOrderExpanded;
|
|
}
|
|
|
|
TQValueVector<int> QuerySchema::pkeyFieldsOrder()
|
|
{
|
|
if (d->pkeyFieldsOrder)
|
|
return *d->pkeyFieldsOrder;
|
|
|
|
TableSchema *tbl = masterTable();
|
|
if (!tbl || !tbl->primaryKey())
|
|
return TQValueVector<int>();
|
|
|
|
//get order of PKEY fields (e.g. for rows updating or inserting )
|
|
IndexSchema *pkey = tbl->primaryKey();
|
|
pkey->debug();
|
|
debug();
|
|
d->pkeyFieldsOrder = new TQValueVector<int>( pkey->fieldCount(), -1 );
|
|
|
|
const uint fCount = fieldsExpanded().count();
|
|
d->pkeyFieldsCount = 0;
|
|
for (uint i = 0; i<fCount; i++) {
|
|
QueryColumnInfo *fi = d->fieldsExpanded->at(i);
|
|
const int fieldIndex = fi->field->table()==tbl ? pkey->indexOf(fi->field) : -1;
|
|
if (fieldIndex!=-1/* field found in PK */
|
|
&& d->pkeyFieldsOrder->at(fieldIndex)==-1 /* first time */)
|
|
{
|
|
KexiDBDbg << "QuerySchema::pkeyFieldsOrder(): FIELD " << fi->field->name()
|
|
<< " IS IN PKEY AT POSITION #" << fieldIndex << endl;
|
|
// (*d->pkeyFieldsOrder)[j]=i;
|
|
(*d->pkeyFieldsOrder)[fieldIndex]=i;
|
|
d->pkeyFieldsCount++;
|
|
// j++;
|
|
}
|
|
}
|
|
KexiDBDbg << "QuerySchema::pkeyFieldsOrder(): " << d->pkeyFieldsCount
|
|
<< " OUT OF " << pkey->fieldCount() << " PKEY'S FIELDS FOUND IN QUERY " << name() << endl;
|
|
return *d->pkeyFieldsOrder;
|
|
}
|
|
|
|
uint QuerySchema::pkeyFieldsCount()
|
|
{
|
|
(void)pkeyFieldsOrder(); /* rebuild information */
|
|
return d->pkeyFieldsCount;
|
|
}
|
|
|
|
Relationship* QuerySchema::addRelationship( Field *field1, Field *field2 )
|
|
{
|
|
//@todo: find existing global db relationships
|
|
Relationship *r = new Relationship(this, field1, field2);
|
|
if (r->isEmpty()) {
|
|
delete r;
|
|
return 0;
|
|
}
|
|
|
|
d->relations.append( r );
|
|
return r;
|
|
}
|
|
|
|
QueryColumnInfo::List* QuerySchema::autoIncrementFields()
|
|
{
|
|
if (!d->autoincFields) {
|
|
d->autoincFields = new QueryColumnInfo::List();
|
|
}
|
|
TableSchema *mt = masterTable();
|
|
if (!mt) {
|
|
KexiDBWarn << "QuerySchema::autoIncrementFields(): no master table!" << endl;
|
|
return d->autoincFields;
|
|
}
|
|
if (d->autoincFields->isEmpty()) {//no cache
|
|
QueryColumnInfo::Vector fexp = fieldsExpanded();
|
|
for (int i=0; i<(int)fexp.count(); i++) {
|
|
QueryColumnInfo *fi = fexp[i];
|
|
if (fi->field->table() == mt && fi->field->isAutoIncrement()) {
|
|
d->autoincFields->append( fi );
|
|
}
|
|
}
|
|
}
|
|
return d->autoincFields;
|
|
}
|
|
|
|
TQString QuerySchema::sqlColumnsList(QueryColumnInfo::List* infolist, Driver *driver)
|
|
{
|
|
if (!infolist)
|
|
return TQString();
|
|
TQString result;
|
|
result.reserve(256);
|
|
QueryColumnInfo::ListIterator it( *infolist );
|
|
bool start = true;
|
|
for (; it.current(); ++it) {
|
|
if (!start)
|
|
result += ",";
|
|
else
|
|
start = false;
|
|
result += driver->escapeIdentifier( it.current()->field->name() );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
TQString QuerySchema::autoIncrementSQLFieldsList(Driver *driver)
|
|
{
|
|
if ((Driver *)d->lastUsedDriverForAutoIncrementSQLFieldsList != driver
|
|
|| d->autoIncrementSQLFieldsList.isEmpty())
|
|
{
|
|
d->autoIncrementSQLFieldsList = QuerySchema::sqlColumnsList( autoIncrementFields(), driver );
|
|
d->lastUsedDriverForAutoIncrementSQLFieldsList = driver;
|
|
}
|
|
return d->autoIncrementSQLFieldsList;
|
|
}
|
|
|
|
void QuerySchema::setWhereExpression(BaseExpr *expr)
|
|
{
|
|
delete d->whereExpr;
|
|
d->whereExpr = expr;
|
|
}
|
|
|
|
void QuerySchema::addToWhereExpression(KexiDB::Field *field, const TQVariant& value, int relation)
|
|
{
|
|
int token;
|
|
if (value.isNull())
|
|
token = SQL_NULL;
|
|
else if (field->isIntegerType()) {
|
|
token = INTEGER_CONST;
|
|
}
|
|
else if (field->isFPNumericType()) {
|
|
token = REAL_CONST;
|
|
}
|
|
else {
|
|
token = CHARACTER_STRING_LITERAL;
|
|
//! @todo date, time
|
|
}
|
|
|
|
BinaryExpr * newExpr = new BinaryExpr(
|
|
KexiDBExpr_Relational,
|
|
new ConstExpr( token, value ),
|
|
relation,
|
|
new VariableExpr((field->table() ? (field->table()->name()+".") : TQString())+field->name())
|
|
);
|
|
if (d->whereExpr) {
|
|
d->whereExpr = new BinaryExpr(
|
|
KexiDBExpr_Logical,
|
|
d->whereExpr,
|
|
AND,
|
|
newExpr
|
|
);
|
|
}
|
|
else {
|
|
d->whereExpr = newExpr;
|
|
}
|
|
}
|
|
|
|
/*
|
|
void QuerySchema::addToWhereExpression(KexiDB::Field *field, const TQVariant& value)
|
|
switch (value.type()) {
|
|
case Int: case UInt: case Bool: case LongLong: case ULongLong:
|
|
token = INTEGER_CONST;
|
|
break;
|
|
case Double:
|
|
token = REAL_CONST;
|
|
break;
|
|
default:
|
|
token = CHARACTER_STRING_LITERAL;
|
|
}
|
|
//! @todo date, time
|
|
|
|
*/
|
|
|
|
BaseExpr *QuerySchema::whereExpression() const
|
|
{
|
|
return d->whereExpr;
|
|
}
|
|
|
|
void QuerySchema::setOrderByColumnList(const OrderByColumnList& list)
|
|
{
|
|
d->orderByColumnList = list;
|
|
// all field names should be found, exit otherwise ..........?
|
|
}
|
|
|
|
OrderByColumnList& QuerySchema::orderByColumnList() const
|
|
{
|
|
return d->orderByColumnList;
|
|
}
|
|
|
|
QuerySchemaParameterList QuerySchema::parameters()
|
|
{
|
|
if (!whereExpression())
|
|
return QuerySchemaParameterList();
|
|
QuerySchemaParameterList params;
|
|
whereExpression()->getQueryParameters(params);
|
|
return params;
|
|
}
|
|
|
|
/*
|
|
new field1, Field *field2
|
|
if (!field1 || !field2) {
|
|
KexiDBWarn << "QuerySchema::addRelationship(): !masterField || !detailsField" << endl;
|
|
return;
|
|
}
|
|
if (field1->isQueryAsterisk() || field2->isQueryAsterisk()) {
|
|
KexiDBWarn << "QuerySchema::addRelationship(): relationship's fields cannot be asterisks" << endl;
|
|
return;
|
|
}
|
|
if (!hasField(field1) && !hasField(field2)) {
|
|
KexiDBWarn << "QuerySchema::addRelationship(): fields do not belong to this query" << endl;
|
|
return;
|
|
}
|
|
if (field1->table() == field2->table()) {
|
|
KexiDBWarn << "QuerySchema::addRelationship(): fields cannot belong to the same table" << endl;
|
|
return;
|
|
}
|
|
//@todo: check more things: -types
|
|
//@todo: find existing global db relationships
|
|
|
|
Field *masterField = 0, *detailsField = 0;
|
|
IndexSchema *masterIndex = 0, *detailsIndex = 0;
|
|
if (field1->isPrimaryKey() && field2->isPrimaryKey()) {
|
|
//2 primary keys
|
|
masterField = field1;
|
|
masterIndex = masterField->table()->primaryKey();
|
|
detailsField = field2;
|
|
detailsIndex = masterField->table()->primaryKey();
|
|
}
|
|
else if (field1->isPrimaryKey()) {
|
|
masterField = field1;
|
|
masterIndex = masterField->table()->primaryKey();
|
|
detailsField = field2;
|
|
//@todo: check if it already exists
|
|
detailsIndex = new IndexSchema(detailsField->table());
|
|
detailsIndex->addField(detailsField);
|
|
detailsIndex->setForeigKey(true);
|
|
// detailsField->setForeignKey(true);
|
|
}
|
|
else if (field2->isPrimaryKey()) {
|
|
detailsField = field1;
|
|
masterField = field2;
|
|
masterIndex = masterField->table()->primaryKey();
|
|
//@todo
|
|
}
|
|
|
|
if (!masterIndex || !detailsIndex)
|
|
return; //failed
|
|
|
|
Relationship *rel = new Relationship(masterIndex, detailsIndex);
|
|
|
|
d->relations.append( rel );
|
|
}*/
|
|
|
|
//---------------------------------------------------
|
|
|
|
QueryAsterisk::QueryAsterisk( QuerySchema *query, TableSchema *table )
|
|
:Field()
|
|
,m_table(table)
|
|
{
|
|
assert(query);
|
|
m_parent = query;
|
|
setType(Field::Asterisk);
|
|
}
|
|
|
|
QueryAsterisk::~QueryAsterisk()
|
|
{
|
|
}
|
|
|
|
Field* QueryAsterisk::copy() const
|
|
{
|
|
return new QueryAsterisk(*this);
|
|
}
|
|
|
|
void QueryAsterisk::setTable(TableSchema *table)
|
|
{
|
|
KexiDBDbg << "QueryAsterisk::setTable()" << endl;
|
|
m_table=table;
|
|
}
|
|
|
|
TQString QueryAsterisk::debugString() const
|
|
{
|
|
TQString dbg;
|
|
if (isAllTableAsterisk()) {
|
|
dbg += "ALL-TABLES ASTERISK (*) ON TABLES(";
|
|
TableSchema *table;
|
|
TQString table_names;
|
|
for (TableSchema::ListIterator it( *query()->tables() ); (table = it.current()); ++it) {
|
|
if (!table_names.isEmpty())
|
|
table_names += ", ";
|
|
table_names += table->name();
|
|
}
|
|
dbg += (table_names + ")");
|
|
}
|
|
else {
|
|
dbg += ("SINGLE-TABLE ASTERISK (" + table()->name() + ".*)");
|
|
}
|
|
return dbg;
|
|
}
|
|
|