Is there any way to take a query object that is stored in a variable (or an
array position) and retrieve the query's name?  I'm quite surprised I
couldn't just say "myQryArray[3].name".

I think what he's asking is how can i find out the name of my query

so given

<cfquery name="qFoobar" datasource="myds">
Select 1
</cfquery>

<cfset myArray[3]=qFooBar>

How would you on myArray[3] be able to work out that the query name was
qFoobar.

Personally I've no idea, and I think it would depend on how the query was
made.

cfdirectory, cfpop, queryNew(), cfquery, cfstoredproc, cfsearch etc

Cheers

Alex

On 10 July 2012 16:42, Jeff Lucido <jluc...@gmail.com> wrote:

Tel: +448452600726
Email: a...@pixl8.co.uk
Web: pixl8.co.uk

Thanks for the quick reply!  No, no... I'm not looking for the column name,
but rather the whole query's name.  In other words, let's say I have the
following...

*
<cfquery name="qryWidgets" datasource="myDS">
     SELECT Number, Widget_Name, Widget_Date
     FROM Widgets
</cfquery>
*

 *<cfset myQ = qryWidgets>*

Now I want to know if there is any way to use the variable *myQ* to get the
name or some other uniquely identifiable information of what query is
stored there.  So basically, if qryWidgets is passed into a CFC, I want my
CFC to be able to determine that myQ points to qryWidgets versus qryCookies
versus qryEmployees.  I know that sounds like it defeats the purpose of a
CFC, but I have a logical reason.  Basically I want my CFC to do something
with an array of queries, but then it's important that the results returned
to the user from my CFC be able to indicate which query a certain piece of
the results came from.  I could leave it up to the user to keep track
of the order in which each query is added to the array that goes to the
CFC, but the simpler I can make this for the user, the better.  The ideal
case would be for the user to send an array of queries to the CFC, then
have the CFC return results that not only show a piece of data, but also
which query that data came from.  More details available upon request.

Please do not send me proprietary file formats such as Word, PowerPoint,
etc. as attachments.
http://www.gnu.org/philosophy/no-word-attachments.html

Please do not send me proprietary file formats such as Word, PowerPoint,
etc. as attachments.
http://www.gnu.org/philosophy/no-word-attachments.html

Also, assuming you're not working with legacy code and it can be easily
changed, perhaps the easiest thing is to simply change from an array of
queries to a struct of queries, in which case the struct key tells you all
you need to know about the original query name.

<cfset myQueryStruct["qFoobar"] = qFoobar>

Then switch it from array of queries to struct of queries, and pass in the
struct of queries.  You'll have the query name immediately available as the
struct key, and you'll have the added benefit of being able to easily check
whether a given query exists before trying to operate on it:

<cffunction name="processStuff"  ...>
   <cfargument name="queryStruct" type="struct" required="true">

  <cfif structkeyexists(arguments.queryStruct,"qWidgets")>
      <!--- do widget query stuff --->
  </cfif>

</cffunction>

The variable name or array position IS the 'query name' in the context
you're asking, specifically it's a reference to the query data contained
therein.  However, if I'm understanding your underlying need and assuming
you've populated an array with a number of queries and you need to
programmatically determine the 'original' name of the query, you should
consider tracking those names either by always making the first array
position be a struct of query names/array positions which you can
reference, or you could do something as simple as include a column alias in
every query so you can check it inline, like so:

<cfquery name="qFoobar" ...>
SELECT 'qFoobar' AS queryName, mytable.*
FROM mytable
</cfquery>

<cfset arrayappend(myQueryArray,qFoobar)>

Then you could get the queryname by simply getting
myQueryArray[3].queryName[1] .  Note this will only work if the query
contains at least one row, and for that reason the other suggestion of
using the array's first position to hold a tracking struct is superior.
Again, this is all making assumptions about what problem you're actually
trying to solve.

Kevin

Or use a two dimensional array

aMyArray[i][1]='MyQueryname';
aMyArray[i][2]=referencetoQueryObject

A

On 10 July 2012 16:55, websolete <websol...@gmail.com> wrote:

Tel: +448452600726
Email: a...@pixl8.co.uk
Web: pixl8.co.uk

But as Matt Said a struct of queries is nicer ;)

A

On 10 July 2012 17:12, Matthew Woodward <m...@mattwoodward.com> wrote:

Tel: +448452600726
Email: a...@pixl8.co.uk
Web: pixl8.co.uk

Wow, lol, too many replies to respond to individually, but thank you all
for the feedback.  I have a much more elegant solution than my original CFC
goal, but I still wanted to challenge myself to see if I could make this
other way work as well.

Just for the record, my exact original intent was for my CFC to take
multiple queries, completely unrelated except they all contain a specific
date field, and return a two-dimensional array that orders the records from
all the queries in chronological order relative to one another.  The first
dimension would indicate which query to look at, and the second dimension
would identify the index.  Then for each record, the user could use the
first dimension to decide what additional data is available.

The original hope was for my CFC to be useable by the most basic of CF
programmers (IE someone not familiar with Structs, etc).  In other words, I
would have liked to set it up so the user could say...

<cfset myCFC.addQuery(qry1)>
<cfset myCFC.addQuery(qry2)>
<cfset myCFC.addQuery(qry3)>
<cfset newOrder = myCFC.doYourThing()>

<cfloop index="i" from="1" to="ArrayLen(newOrder)">
    <cfif newOrder[i][1] EQ "qry1">
        (display specific qry1 info at index newOrder[i][2])
    <cfelseif newOrder[i][2] EQ "qry2">
        (display specific qry2 info at index newOrder[i][2])
    etc etc...
</cfloop>

I think the easiest work-around there would be to have the user specify the
name as a second parameter at the same time as they add the query to the
CFC.  But I just wanted to make sure I wasn't missing something that would
allow me to prevent that extra step for the user.  Afterall, who wants to
explain the difference between...

<cfset myCFC.addQuery(qry1, "qry1")>
and
<cfset myCFC.addQuery("qry1", qry1)>

Please do not send me proprietary file formats such as Word, PowerPoint,
etc. as attachments.
http://www.gnu.org/philosophy/no-word-attachments.html

Actually, scratch that last part.  Easier workaround would be to have the
user keep track of the order in which they add the queries.  Then my my
result could be...

*<cfif newOrder[i][1] EQ 3> <!--- I know qry3 was the third query I added,
so 3 implies qry3 --->*

That shouldn't be too complicated for a basic CF user.

Not to beat a dead horse, since you seem to be happy with your solution,
but if elegant is a goal I would have gone with merging all the queries
into a single query inside the cfc, then queryOfQuery it for the sort you
wanted, returning the merged master query as a single entity, as that's
about as simple as you can get to work with for output.

Regarding your comment about this:

<cfset myCFC.addQuery(qry1, "qry1")>

Lol, well let me rephrase that by saying I'd want this to be useable by
someone who isn't a developer by trade and only occasionally dusts off his
programmer mits.  And personally I usually consider Arrays to be the
threshold of "basic".  Even I'm a little rusty on Structs, and I've been
programming in CF for years.  I just haven't needed them. *shrug*

Ah, my problem there was that the queries could contain different fields
and different numbers of fields.  The only definites are the Date and
a record number unique to the query. So one big master query was
technically out of the question.  I did however end up using a query of
queries to pull and sort just the unique number, the date, and a custom
"whichQuery" field from each query.  Then when outputing that QofQ, I could
run another QofQ using the unique number and "whichQuery" to get the rest
of the data for that record from the associated original query.

I think you're missing out on one of the most basic and powerful constructs
in CF (and many other languages) then.  I also think you may not be seeing
the forest for the trees.  Every time you reference a url, form,
application, session, etc., variable you're working with structs.  Does it
get any easier than <cfset session.loggedIn = true> ?  Not by much, if at
all.

The only difference, to me, between structs and arrays is one uses a string
for the key and the other uses a number.  For your purposes of this CFC,
you're just using a 2D array as a 'container' for a few things, so you're
not going to get the performance benefit of an array vs. a struct (arrays
perform better than structs with a large number of keys).  You're also not
getting the benefit of simplifying the references to the queries contained
within the 'container' by using struct notation.

By all means, do what you're comfortable with, but to my eye, you're adding
a needless level of complexity to your code to adhere to an odd standard of
what 'basic' constitutes.

This is addressed easily enough.  Sorry, OCD kicking in and I'm feeling
helpful to boot.  Consider the following not-so-pseudo code:

<cffunction name="mergeQueries"... returntype="query">
    <cfargument name="queries" type="struct" required="true">

    <!--- assume arguments.queries contains these three struct keys, which
themselves are queries :
        query1:  thedate, name, flavor, size
        query2: thedate, origin, dimension
        query3: thedate, name, destination
    --->

    <cfset var columns = ""><!--- master column list, will be used to
create the master merge query --->
    <cfset var q = "">
    <cfset var c = "">
    <cfset var merged = "">
    <cfset var temp = "">

    <cftry>

        <!--- add each query's columns which haven't been added to the
master list --->
        <cfloop collection="#arguments.queries#" item="q">
            <cfif isquery(arguments.queries[q])><!--- ensure its a query
--->
                <cfloop list="#arguments.queries[q].columnlist#"
index="c"><!--- loops the columns in the current query --->
                    <cfif not listfindnocase(columns,c)><!--- column isn't
in the master columns list --->
                        <cfset columns = listappend(columns,c)>
                    </cfif>
                </cfloop>
            </cfif>
        </cfloop>

        <!--- create the master query --->
        <cfset merged = querynew(columns)>

        <!--- loop the queries and add their data to the master query --->
        <cfloop collection="#arguments.queries#" item="q">
            <cfif isquery(arguments.queries[q]) and
arguments.queries[q].recordcount><!--- ensure it's a query and make sure it
has data --->
                <cfset temp = arguments.queries[q]><!--- easier reference
to the query --->
                <cfloop query="temp">
                    <cfset queryaddrow(merged,1)>
                    <cfloop list="#temp.columnlist#" index="c"><!---loop
the columns in the current query, only setting those values in the master,
others will be 'null' --->
                        <cfset
querysetcell(merged,c,temp[c][currentrow])><!---by default is setting
values for the last row --->
                    </cfloop>
                </cfloop>
            </cfif>
        </cfloop>

        <cfquery dbtype="query" name="q">
            SELECT *
            FROM merged
            ORDER BY thedate ASC
        </cfquery>

        <cfreturn q><!--- the returned query will be a merge of all queries
in the struct, and for each row, those columns which didn't exist in a
given query will simply be an empty string --->

        <cfcatch>
            <cfrethrow>
        </cfcatch>

    </cftry>

</cffunction>

Oh I don't disagree... but don't get me wrong, I am passionately in love
with OOP.  I live and breathe Javascript, and I use my own custom objects
and attributes there all the time.  I only consider CF "structs" to not be
basic because of my outdated education.  The programming portion
of my Bachelors was basically "Here are numbers, strings, if's, loops, and
arrays. Now here is 3.5 years of how to use those data types to accomplish
everything. Oh and here is some SQL.".  I tought myself Javascript and
Coldfusion, primarily only using CF to get my data and maintain SESSIONs.  
I never really got hooked on custom structs because I've never really
needed them.  Typically I just use JS for any dynamic objects.

As for my CFC example, I'm not hell-bent on using an array.  A struct is
just fine as well.  I was just hoping to find a solution that didn't
require the user to know either.  I just wanted him to be able to feed
queries into the CFC.  It's much more dummy-proof that way.

Ahh I see what you mean!  You were implying I add ALL the fields to my
master query, leaving nulls where appropriate. My object-oriented logic
just completely skipped over that notion.  Fair suggestion!

Lol, thanks for looking out for me Al.  It looks like the general
consensus is exactly what you said.  There were some good workarounds to
get to my end-goal, but it's good to know for future reference that not
every property of every object I can set is available to retrieve.

Hi Matt,

Thats the key thing by setting the name I don't' think you're setting a
property on the object, you're saying the name of the variable I want
created which will hold the query object.

Look at QueryNew() if it was a property wouldn't you have to specify it in
that function as well.

A

On 11 July 2012 13:50, Matt C <creech...@gmail.com> wrote:

Tel: +448452600726
Email: a...@pixl8.co.uk
Web: pixl8.co.uk