/**
* full one row data
*
* @param nRow row number, base 1
* @param nBeg column begin, base 1
* @prarm data
*/
void excelreader::SetData(int nRow, int nBeg,
const std::list<std::wstring>& data)
{
if (data.size() <= 0)
{
return;
}
int nEnd = nBeg + static_cast<int>(data.size()) - 1;
// create array
CComSafeArray<VARIANT> arr(static_cast<ULONG>(0));
for (std::list<std::wstring>::const_iterator it = data.begin();
it != data.end(); ++it)
{
arr.Add(_variant_t(it->c_str()).Detach(), FALSE);
}
VARIANT vArr;
vArr.vt = VT_ARRAY | VT_VARIANT;
vArr.parray = (SAFEARRAY*)arr;
// select range
WCHAR szTmp[4];
wsprintfW(szTmp, L"%i", nRow);
std::wstring sTmp = GetColumnName(nBeg) + szTmp + L":"
+ GetColumnName(nEnd) + szTmp;
_variant_t parm(sTmp.c_str());
_variant_t result;
AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range",
1, (VARIANT)parm);
//full the range
AutoWrap(DISPATCH_PROPERTYPUT, NULL, result.pdispVal, L"Value",
1, vArr);
}
QString SimpleDBStorage::GetSetClause(MSqlBindings &bindings) const
{
QString tagname(":SET" + GetColumnName().toUpper());
QString clause(GetColumnName() + " = " + tagname);
bindings.insert(tagname, user->GetDBValue());
return clause;
}
QString GenericDBStorage::GetSetClause(MSqlBindings &bindings) const
{
QString keycolumnTag = ":SETKEY" + keycolumn.toUpper();
QString columnTag = ":SETCOL" + GetColumnName().toUpper();
bindings.insert(keycolumnTag, keyvalue);
bindings.insert(columnTag, user->GetDBValue());
return keycolumn + " = " + keycolumnTag + ", " +
GetColumnName() + " = " + columnTag;
}
QString ChannelDBStorage::GetSetClause(MSqlBindings &bindings) const
{
QString fieldTag = (":SET" + id.getField().toUpper());
QString nameTag = (":SET" + GetColumnName().toUpper());
QString query(id.getField() + " = " + fieldTag + ", " +
GetColumnName() + " = " + nameTag);
bindings.insert(fieldTag, id.getValue());
bindings.insert(nameTag, user->GetDBValue());
return query;
}
QString ProfileGroupStorage::GetSetClause(MSqlBindings &bindings) const
{
QString idTag(":SETID");
QString colTag(":SET" + GetColumnName().toUpper());
QString query("id = " + idTag + ", " +
GetColumnName() + " = " + colTag);
bindings.insert(idTag, m_parent.getProfileNum());
bindings.insert(colTag, user->GetDBValue());
return query;
}
QString GameDBStorage::GetSetClause(MSqlBindings &bindings) const
{
QString playerID(":SETPLAYERID");
QString colTag(":SET" + GetColumnName().toUpper());
QString query("gameplayerid = " + playerID + ", " +
GetColumnName() + " = " + colTag);
bindings.insert(playerID, parent.getGamePlayerID());
bindings.insert(colTag, user->GetDBValue());
return query;
}
QString GetSetClause(MSqlBindings &bindings) const override // SimpleStorage
{
bindings.insert(":SETPLAYERID", m_id.Value());
bindings.insert(":SETCOLUMN", m_user->GetDBValue());
return QString("gameplayerid = :SETPLAYERID, "
"%2 = :SETCOLUMN").arg(GetColumnName());
}
void SimpleDBStorage::Load(void)
{
MSqlQuery query(MSqlQuery::InitCon());
MSqlBindings bindings;
query.prepare(
"SELECT CAST(" + GetColumnName() + " AS CHAR)"
" FROM " + GetTableName() +
" WHERE " + GetWhereClause(bindings));
query.bindValues(bindings);
if (!query.exec() || !query.isActive())
{
MythDB::DBError("SimpleDBStorage::Load()", query);
}
else if (query.next())
{
QString result = query.value(0).toString();
// a 'NULL' QVariant does not get converted to a 'NULL' QString
if (!query.value(0).isNull())
{
initval = result;
user->SetDBValue(result);
}
}
}
double excelreader::GetDataAsDouble(int row, int col) {
if (row < 0 || col < 0)
throw ExcelException("cell not exit");
WCHAR szTmp[5];
wsprintfW(szTmp, L"%i", row);
std::wstring sTmp = GetColumnName(col) + szTmp + L":"
+ GetColumnName(col) + szTmp;
_variant_t parm(sTmp.c_str());
_variant_t result;
AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range",
1, (VARIANT)parm);
_variant_t data;
AutoWrap(DISPATCH_PROPERTYGET, &data, result.pdispVal, L"Value", 0);
return (double)data;
}
void InputColumnDeriver::Visit(const QueryDerivedScan *op) {
// QueryDerivedScan should only be a renaming layer
ExprMap output_cols_map;
for (auto expr : required_cols_) {
expression::ExpressionUtil::GetTupleValueExprs(output_cols_map, expr);
}
vector<AbstractExpression *> output_cols =
vector<AbstractExpression *>(output_cols_map.size());
ExprMap input_cols_map;
vector<AbstractExpression *> input_cols(output_cols.size(), nullptr);
for (auto &entry : output_cols_map) {
auto tv_expr =
reinterpret_cast<expression::TupleValueExpression *>(entry.first);
output_cols[entry.second] = tv_expr;
// Get the actual expression
auto input_col = const_cast<QueryDerivedScan *>(op)
->alias_to_expr_map[tv_expr->GetColumnName()]
.get();
// QueryDerivedScan only modify the column name to be a tv_expr, does not
// change the mapping
input_cols[entry.second] = input_col;
}
output_input_cols_ =
pair<vector<AbstractExpression *>, vector<vector<AbstractExpression *>>>{
output_cols, {input_cols}};
}
bool Tile::SerializeHeaderTo(SerializeOutput &output) {
std::size_t start;
// Use the cache if possible
if (column_header != NULL) {
PL_ASSERT(column_header_size != INVALID_OID);
output.WriteBytes(column_header, column_header_size);
return true;
}
PL_ASSERT(column_header_size == INVALID_OID);
// Skip header position
start = output.Position();
output.WriteInt(-1);
// Status code
output.WriteByte(-128);
// Column counts as a short
output.WriteShort(static_cast<int16_t>(column_count));
// Write an array of column types as bytes
for (oid_t column_itr = 0; column_itr < column_count; ++column_itr) {
type::Type::TypeId type = schema.GetType(column_itr);
output.WriteByte(static_cast<int8_t>(type));
}
// Write the array of column names as strings
// NOTE: strings are ASCII only in metadata (UTF-8 in table storage)
for (oid_t column_itr = 0; column_itr < column_count; ++column_itr) {
// Column name: Write (offset, length) for column definition, and string to
// string table
const std::string &name = GetColumnName(column_itr);
// Column names can't be null, so length must be >= 0
int32_t length = static_cast<int32_t>(name.size());
PL_ASSERT(length >= 0);
// this is standard string serialization for voltdb
output.WriteInt(length);
output.WriteBytes(name.data(), length);
}
// Write the header size which is a non-inclusive int
size_t Position = output.Position();
column_header_size = static_cast<int32_t>(Position - start);
int32_t non_inclusive_header_size =
static_cast<int32_t>(column_header_size - sizeof(int32_t));
output.WriteIntAt(start, non_inclusive_header_size);
// Cache the column header
column_header = new char[column_header_size];
PL_MEMCPY(column_header, static_cast<const char *>(output.Data()) + start,
column_header_size);
return true;
}
int DefaultRoomColumns::GetColumnIndex(const char *columnName)
{
unsigned i;
for (i=0; i < TC_TABLE_COLUMNS_COUNT; i++)
if (strcmp(columnName,GetColumnName(i))==0)
return i;
return -1;
}
bool DefaultRoomColumns::HasColumnName(const char *columnName)
{
unsigned i;
for (i=0; i < TC_TABLE_COLUMNS_COUNT; i++)
if (strcmp(columnName,GetColumnName(i))==0)
return true;
return false;
}
void CMuleListCtrl::SaveSettings()
{
wxCHECK_RET(!m_name.IsEmpty(), wxT("Cannot save settings for unnamed list"));
wxConfigBase* cfg = wxConfigBase::Get();
// Save sorting, column and order
wxString sortOrder;
for (CSortingList::iterator it = m_sort_orders.begin(); it != m_sort_orders.end();) {
wxString columnName = GetColumnName(it->first);
if (!columnName.IsEmpty()) {
sortOrder += columnName;
sortOrder += wxT(":");
sortOrder += it->second & SORT_DES ? wxT("1") : wxT("0");
sortOrder += wxT(":");
sortOrder += it->second & SORT_ALT ? wxT("1") : wxT("0");
if (++it != m_sort_orders.end()) {
sortOrder += wxT(",");
}
} else {
++it;
}
}
cfg->Write(wxT("/eMule/TableOrdering") + m_name, sortOrder);
// Save column widths. ATM this is also used to signify hidden columns.
wxString buffer;
for (int i = 0; i < GetColumnCount(); ++i) {
wxString columnName = GetColumnName(i);
if (!columnName.IsEmpty()) {
if (!buffer.IsEmpty()) {
buffer << wxT(",");
}
int currentwidth = GetColumnWidth(i);
int savedsize = (m_column_sizes.size() && (i < (int) m_column_sizes.size())) ? m_column_sizes[i] : 0;
buffer << columnName << wxT(":") << ((currentwidth > 0) ? currentwidth : (-1 * savedsize));
}
}
cfg->Write(wxT("/eMule/TableWidths") + m_name, buffer);
}
std::string excelreader::GetDataAsString(int row, int col) {
if (row < 0 || col < 0)
throw ExcelException("Cell not exit");
WCHAR szTmp[6];
wsprintfW(szTmp, L"%i", row);
std::wstring sTmp = GetColumnName(col) + szTmp + L":"
+ GetColumnName(col) + szTmp;
_variant_t parm(sTmp.c_str());
_variant_t result;
AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range",
1, (VARIANT)parm);
_variant_t data;
AutoWrap(DISPATCH_PROPERTYGET, &data, result.pdispVal, L"Value", 0);
//if (VariantChangeType(&data, &data, 0, VT_BSTR) != S_OK) {
// throw ExcelException("Cannot convert data to string");
//}
//CW2A ansiBuffer((_bstr_t)data);
//CT2A cc((_bstr_t)data);
//std::string s(cc);
return tostr(data);
}
uint32 DBRowDescriptor::FindColumn( const char* name ) const
{
uint32 cc = ColumnCount();
PyString* stringName = new PyString( name );
for( uint32 i = 0; i < cc; i++ )
{
if( stringName->hash() == GetColumnName( i )->hash() )
{
PyDecRef( stringName );
return i;
}
}
PyDecRef( stringName );
return cc;
}
void OperatorToPlanTransformer::Visit(const PhysicalProject *) {
auto project_prop = requirements_->GetPropertyOfType(PropertyType::PROJECT)
->As<PropertyProjection>();
(void)project_prop;
size_t project_list_size = project_prop->GetProjectionListSize();
// expressions to evaluate
TargetList tl = TargetList();
// columns which can be returned directly
DirectMapList dml = DirectMapList();
// schema of the projections output
std::vector<catalog::Column> columns;
for (size_t project_idx = 0; project_idx < project_list_size; project_idx++) {
auto expr = project_prop->GetProjection(project_idx);
std::string column_name;
// if the root of the expression is a column value we can
// just do a direct mapping
if (expr->GetExpressionType() == ExpressionType::VALUE_TUPLE) {
auto tup_expr = (expression::TupleValueExpression *)expr;
column_name = tup_expr->GetColumnName();
dml.push_back(
DirectMap(project_idx, std::make_pair(0, tup_expr->GetColumnId())));
}
// otherwise we need to evaluat the expression
else {
column_name = "expr" + std::to_string(project_idx);
tl.push_back(Target(project_idx, expr->Copy()));
}
columns.push_back(catalog::Column(
expr->GetValueType(), type::Type::GetTypeSize(expr->GetValueType()),
column_name));
}
// build the projection plan node and insert aboce the scan
std::unique_ptr<planner::ProjectInfo> proj_info(
new planner::ProjectInfo(std::move(tl), std::move(dml)));
std::shared_ptr<catalog::Schema> schema_ptr(new catalog::Schema(columns));
std::unique_ptr<planner::AbstractPlan> project_plan(
new planner::ProjectionPlan(std::move(proj_info), schema_ptr));
output_plan_ = std::move(project_plan);
}
void ctlSQLGrid::AppendColumnHeader(wxString &str, wxArrayInt columns)
{
if(settings->GetColumnNames())
{
bool CopyQuoting = (settings->GetCopyQuoting() == 1 || settings->GetCopyQuoting() == 2);
size_t i;
for(i = 0; i < columns.Count() ; i++)
{
long columnPos = columns.Item(i);
if(i > 0)
str.Append(settings->GetCopyColSeparator());
if(CopyQuoting)
str.Append(settings->GetCopyQuoteChar());
str.Append(GetColumnName(columnPos));
if(CopyQuoting)
str.Append(settings->GetCopyQuoteChar());
}
str.Append(END_OF_LINE);
}
}
bool
StatementObject::Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
//sprintf(tmp, "stmt Invoke [%s]\n", NPN_UTF8FromIdentifier(name)); log(tmp);
NPError rc;
VOID_TO_NPVARIANT(*result);
int index = 0;
if (name == mc_Init_id) {
if (argCount < 2) {
NPN_SetException(this, "Too few parameters count");
return true;
}
#if 0
if (!(NPVARIANT_IS_INT32(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) {
NPN_SetException(this, "Wrong argument type");
return true;
}
SQLHANDLE hdbc = (SQLHANDLE)(long)NPVARIANT_TO_INT32(args[0]);
#else
if (!(NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) {
NPN_SetException(this, "Wrong argument type");
return true;
}
SQLHANDLE hdbc = (SQLHANDLE)NPVARIANT_TO_OBJECT(args[0]);
#endif
Init(hdbc, NPVARIANT_TO_OBJECT(args[1]));
return true;
} else if (name == mc_AddParameter_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
AddParam(args);
return true;
} else if (name == mc_Execute_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!NPVARIANT_IS_STRING(args[0])) {
NPN_SetException(this, "Wrong argument type");
return true;
}
Execute((NPString*)&NPVARIANT_TO_STRING(args[0]));
return true;
} else if (name == mc_Close_id) {
Close();
return true;
} else if (name == mc_Fetch_id) {
bool ret;
rc = Fetch(&ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_MoreResults_id) {
bool ret;
rc = MoreResults(&ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetColumnName_id) {
const char *ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = GetColumnName(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
STRING_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetVariant_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
GetVariant(index, result);
return true;
} else if (name == mc_GetColumnType_id) {
int ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = GetColumnType(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
INT32_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_IsColumnNullable_id) {
bool ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = IsColumnNullable(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetTables_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetTables(&args[0], &args[1], &args[2], &args[3]);
return true;
} else if (name == mc_GetColumns_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetColumns(&args[0], &args[1], &args[2], &args[3]);
return true;
} else if (name == mc_GetTypeInfo_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
GetTypeInfo(index);
return true;
} else if (name == mc_GetPrimaryKeys_id) {
if (argCount < 3) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
GetPrimaryKeys(&args[0], &args[1], &args[2]);
return true;
} else if (name == mc_GetForeignKeys_id) {
if (argCount < 6) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[4]) || NPVARIANT_IS_STRING(args[4]))) {
NPN_SetException(this, "Wrong 5 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[5]) || NPVARIANT_IS_STRING(args[5]))) {
NPN_SetException(this, "Wrong 6 argument type");
return true;
}
GetForeignKeys(&args[0], &args[1], &args[2], &args[3], &args[4], &args[5]);
return true;
} else if (name == mc_GetProcedures_id) {
if (argCount < 3) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
GetProcedures(&args[0], &args[1], &args[2]);
return true;
} else if (name == mc_GetProcedureColumns_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetProcedureColumns(&args[0], &args[1], &args[2], &args[3]);
return true;
}
return false;
}
//*****************************************************************************
void CBCGPDBGridCtrl::Sort (int nColumn, BOOL bAscending, BOOL bAdd)
{
if (m_bIsSorting || !CanSortByColumn (nColumn))
{
return;
}
if (!m_bDbSort || m_strSQL.IsEmpty ())
{
CBCGPGridCtrl::Sort (nColumn, bAscending, bAdd);
return;
}
SetCurSel (NULL);
m_CachedItems.CleanUpCache ();
CString strSQLOrign = m_strSQL;
CString strColumn = GetColumnName (nColumn);
if (strColumn.Find (_T(' ')) >= 0)
{
strColumn = _T('\'') + strColumn + _T('\'');
}
CString strSQL;
strSQL.Format (_T("%s ORDER BY %s %s"),
m_strSQL, strColumn,
bAscending ? _T(" ASC") : _T(" DESC"));
if (bAdd)
{
for (POSITION pos = m_Columns.m_mapSortColumn.GetStartPosition (); pos != NULL; )
{
int nListColumn, nState;
m_Columns.m_mapSortColumn.GetNextAssoc (pos, nListColumn, nState);
if (nState != 0 && nListColumn != nColumn)
{
CString strListColumn = GetColumnName (nListColumn);
if (strListColumn.Find (_T(' ')) >= 0)
{
strListColumn = _T('\'') + strListColumn + _T('\'');
}
CString strOrder;
strOrder.Format (_T(", %s %s"),
strListColumn,
nState > 0 ? _T(" ASC") : _T(" DESC"));
strSQL += strOrder;
}
}
}
CWaitCursor wait;
m_bRebuildTerminalItems = TRUE;
m_bIsSorting = TRUE;
if (OpenSQL (strSQL))
{
m_Columns.SetSortColumn (nColumn, bAscending, bAdd);
}
RedrawWindow (m_rectHeader);
m_bIsSorting = FALSE;
m_strSQL = strSQLOrign;
}
TdsColumnData::TdsColumnData(TDSCOLUMN* pColumn)
{
m_nColumnType = GetColumnType(pColumn);
m_nColumnSize = GetColumnSize(pColumn);
m_strColumnName = GetColumnName(pColumn);
}
CString IllusionExcelFile::RCString(int irow,int icol){
CString tmp;
tmp.Format(_T("%s%d"),GetColumnName(icol),irow);
return tmp;
}
