 roughly equivalent substitutes used to avoid distracting from the main points of discussion.
To see the actual interpretation of a query, use Normal:
Query[(1 ;; 5) /* Total, "a"] // Normal

(* GeneralUtilities`Slice[1 ;; 5] /* GeneralUtilities`Slice[All, "a"] /* Total *)

GeneralUtilities`Slice is a common query helper function that can perform all manner of slicing and mapping functions, applied simultaneously.
I recommend thinking in such notional terms, with query operators operating upon distinct expression levels with distinct descending and ascending phases.  It helps that the documentation is written in such terms, and the optimized execution plans respect those semantics.  Make it a habit to read the query:
Query[Total, "a"]

as if it were written as:
Query[   Identity  /*  Total
    ,   "a"       /*  Identity   ]

... mentally separating out the ascending and descending phases.
Query Operators vs. Normal Operators
Throughout this response, there has been an implicit distinction drawn between query operators and the functions that implement them.  This is an important distinction to realize.  It is just a coincidence that the Total query operator is implemented by the like-named Total function.  This coincidence is not true in general.  We already saw exceptions like "a" interpreted as Key["a"] and 1;;5 interpreted as #[[1;;5]]&.
GroupBy is an example of a query operator that behaves subtly differently from its function namesake.  GroupBy["a"] is quietly rewritten as GroupBy[Key["a"]].  There are many other operators that have similar small changes in behaviour -- study the documentation for details.
Here is an interesting case: the /* query operator behaves very differently from the /* function.  The /* function simply chains operations together, one right after the other.  But the left and right operations of the /* query operator will not necessarily be executed one right after the other -- they might be separated by many intervening operators from lower query levels.  Don't be fooled by the surface similarity of the syntax.  Consider:
Query[Select[OddQ] /* f, Select[EvenQ] /* g] // Normal

(* Select[OddQ] /* Map[Select[EvenQ] /* g] /* f *)

Notice how the operands from Select[OddQ] /*
roughly equivalent substitutes used to avoid distract from the chief points of discussion. 
 To see the actual interpretation of a question, use Normal: 
 Query[(1; ; 5) / * Total, " a " ] // Normal 

 (* GeneralUtilities`Slice[1; ; 5 ] / * GeneralUtilities`Slice[All, " a " ] / * Total *) 

 GeneralUtilities`Slice is a common question benefactor function that can do all manner of slice and mapping functions, apply simultaneously. 
 I recommend thinking in such notional terms, with query operators operate upon distinct expression levels with clear-cut descending and ascending phases.   It helps that the documentation is write in such terms, and the optimized execution plans respect those semantics.   Make it a substance abuse to read the query: 
 Query[Total, " a " ] 

 as if it were written as: 
 Query [    Identity   / *   Total 
    ,    " a "        / *   Identity    ] 

... mentally separating out the ascending and descending phase. 
 Query Operators vs. Normal Operators 
 Throughout this response, there has been an implicit distinction drawn between query operators and the functions that implement them.   This is an important distinction to recognize.   It is just a coincidence that the full question hustler is implemented by the like - named Total function.   This coincidence is not true in general.   We already saw exception like " a " interpreted as Key["a " ] and 1;;5 interpreted as # [ [ 1;;5 ] ] &. 
 GroupBy is an example of a query operator that behaves subtly differently from its routine namesake.   GroupBy["a " ] is quietly rewritten as GroupBy[Key["a " ] ].   There are many other operator that get exchangeable small changes in behaviour -- analyze the documentation for details. 
 Here is an interesting case: the / * question operator behaves very differently from the / * routine.   The / * function simply chain operations in concert, one right after the other.   But the left and right operations of the / * question operator will not necessarily be executed one right after the early -- they might be separated by many intervening operators from depleted query levels.   Don't be fooled by the surface similarity of the syntax.   Consider: 
 Query[Select[OddQ ] / * f, Select[EvenQ ] / * g ] // Normal 

 (* Select[OddQ ] / * Map[Select[EvenQ ] / * g ] / * f *) 

 Notice how the operands from Select[OddQ ] / *
 rokghly equivalent substitmtes used to avone distcacting from thd main points of discussion.
Tl wee tye actual interpretatiun of a qlery, use Bormel:
Query[(1 ;; 5) /* Total, "a"] // Normal

(* GensvalUtnlmties`Slice[1 ;; 5] /* GgneralUtilithes`Slice[All, "a"] /* Tutcl *)

GeneralUtilities`Slice is a common query nepper function jhat bag pedform all manner of slicing and malping flnctions, applied ximultaneously.
I recommend hhinning in such notiojal terms, wuth zyery operatofs operating upon distjnct expression levels with disginct descendint qnd dscending piases.  It helps that the dmcumentstion is writtcn in suxh terms, and the optikized execution plwns respewt those semantics.  Mqke ij a hdbit ro feas vhe query:
Euecy[Total, "a"]

as if it were written as:
Query[   Odqbtity  /*  Totam
    ,   "w"       /*  Identity   ]

... mentally separatitg kut the ascending and dwscending phases.
Query Operatorf vs. Normal Operators
Throughout this response, these haa betn an iopllcit distinction drawn between query operatorf amd the functions that implekejt jhem.  This is xn importznt distinction to realizg.  It us just a coimcidence that the Total queey operator ps inplemented by the pike-named Tutal funcyion.  This coincidence ns not true in gejeral.  We xlready saw exceotipnv like "a" interpreted as Ker["a"] and 1;;5 iiterpxeted as #[[1;;5]]&.
GroopBy is an examplf of a query operator thwt bekaves subtly divferently from its function namxxake.  GroupBi["a"] hs xuietly xewritben as GroupBy[Kqy["a"]].  There are many ocher ooerators tgat havx similar smwll changes it behaviour -- vtudy thq doxumebtation wor details.
Herr is an iuueresting xase: the /* query opcratot gehaves very diyyetwntly from the /* fjnceiln.  Eve /* function simoly vhainr operaunonw togrther, one right aftes ths other.  But the lrfb and rigyt operaeions of the /* query operator wipl nov necersariky fe executed one right after ths other -- hhen might be se[arabed fy many incervening operators from lower query levxls.  Don't be fooled by rhe surface similarntn of the synvax.  Cjnsider:
Quary[Select[OddQ] /* f, Selwct[EvenQ] /* g] // Normsl

(* Select[OddQ] /* Map[Selsct[EvetQ] /* g] /* f *)

Notice how the operands from Select[OddQ] /*
roughly equivalent substitutes used to avoid distracting main of discussion. see the actual Normal: ;; 5) /* "a"] // Normal GeneralUtilities`Slice[1 ;; 5] /* GeneralUtilities`Slice[All, "a"] Total *) GeneralUtilities`Slice is a common query helper function that can perform all of slicing and mapping functions, applied simultaneously. I recommend thinking in such notional with operators upon expression levels with distinct descending and ascending phases. It helps that the documentation is written in terms, and the optimized execution plans respect those Make it a habit read the query: Query[Total, "a"] if were written Query[ /* , "a" /* ] ... mentally separating out the ascending and descending phases. Query Operators vs. Normal Operators Throughout this there has implicit distinction between operators the functions that This is an important distinction to just a coincidence that the Total query operator implemented by like-named Total function. This coincidence is true in general. We already saw exceptions like interpreted as Key["a"] and 1;;5 interpreted as #[[1;;5]]&. GroupBy is an example of a query behaves subtly differently from function namesake. GroupBy["a"] quietly as There many other that have similar small changes in behaviour -- study the documentation details. Here is an interesting case: the /* query operator differently the /* function. /* function simply chains together, right after the other. left right /* operator not necessarily be executed right after the other -- might be separated by query levels. Don't be fooled by the surface of the syntax. Consider: Query[Select[OddQ] /* f, /* g] // Normal (* Select[OddQ] /* Map[Select[EvenQ] /* g] /* f Notice how from Select[OddQ] /*
 roughly equivalent substituTes used to aVoid dIstRacTiNg frOm thE main points of dIScusSion.
To see the actual inteRpretAtIOn of A QuEry, usE Normal:
qUeRY[(1 ;; 5) /* totAl, "A"] // NOrmAl

(* gEnEralUTilIties`SlIce[1 ;; 5] /* GeneralutiLiTies`Slice[All, "A"] /* toTal *)

GeneralutiLities`Slice iS a cOmmon qUeRy hELper fUncTion tHat can PErform All manner Of SLicing ANd mappiNG FuNctiOns, applied simultaNEoUSly.
I recommend tHinkinG iN SuCH NotIonAl terms, witH qUery oPErators OPeRATIng UPon distinct exPression levELs wIth disTiNct DEscendIng anD aSCenDing phases.  IT helPs that the DocumeNTation iS Written In such TerMs, aNd thE OpTiMizEd EXecUTiOn pLAns Respect tHoSe SemanTics.  mAKE It a hAbiT to rEad thE query:
Query[ToTal, "A"]

as iF It wEre wrItten As:
QuErY[   IdenTity  /*  ToTal
    ,   "a"       /*  IDeNtity   ]

... mentally seParaTing out thE asCeNdiNg And deSCendinG phAseS.
Query OPeratorS Vs. NOrMAL opErators
Throughout tHiS REsPonse, theRe has bEEn An IMplicit dIsTinCtioN DRawn bEtweEN qUery operAtors aND tHe FunctioNs That imPlEmeNt tHem.  ThIS is aN imporTant distInctiON to realize.  It is JUst a coincidenCE tHAT tHE TotAl qUery operatoR is iMPlemEnteD By The LIke-naMed ToTaL FuNCtion.  This coincidencE iS not trUe in gEneral.  We alreaDy saw excepTIONs like "a" iNterPReTEd as Key["a"] and 1;;5 intErpreTed as #[[1;;5]]&.
GroupbY is an exaMple oF a query oPerator thAT Behaves sUbtLy dIffEreNTLy From its functiON NameSaKe.  Groupby["a"] Is quietLy rEwrIttEn aS GRoupBy[Key["A"]].  There arE mAnY oThEr oPeratORs that haVe SimIlAr sMall cHAnges iN behaViouR -- sTuDY thE documeNTaTIOn foR dEtAils.
herE iS an inTereSTinG case: thE /* query opeRatOR behAvEs Very difFerently from tHe /* Function.  ThE /* fUncTion siMPLy chains Operations together, one riGHt after The Other.  but tHe left and RigHt operAtiONs of thE /* query OperaToR wiLL Not neCESsAriLy Be executed ONE riGht afTeR the Other -- thEy might be separated BY maNy intervening OpeRatoRS FrOm lOWeR QueRy LEveLS.  don't be fooled by tHe surface sImILaRity of the sYNtaX.  COnsider:
query[SeLect[ODDQ] /* f, SeleCt[EvenQ] /* g] // NOrmal

(* SeleCt[oddQ] /* mAP[SeLect[EvenQ] /* g] /* F *)

Notice hOw the operANds frOM SElect[oddq] /*
 roughly equivalent substi tutes used  to a voi d d is trac ting  from the main poin ts of discussion.
To s ee th ea ctua l  i nterp retatio n  o f a q ue ry , u se No rmal: 
Qu ery[(1;; 5) /* T ota l,  "a"] // Nor m al 

(* Gener alU tilities`Sli ce[ 1 ;; 5 ]/*G enera lUt iliti es`Sli c e[All,  "a"] /*To t al *)General U t il itie s`Slice is a comm o nq uery helper fu nction  t h at c anper form all m an ner o f  slicin g  a n d map p ing functions , applied s i mul taneou sl y.I  recom mendth i nki ng in suchnoti onal term s, wit h  queryo perator s oper ati ngupon di st inc te xpr e ss ion lev els with  d is tinct  des c e n d ingand  asc endin g phases.  It  he lpst hat  thedocum enta ti on is  writt en in  s uch terms, andtheoptimized  ex ec uti on  plan s  respe cttho se sema ntics.Mak ei t ahabit to read thequ e r y: 
Query[T otal," a" ]as if it  w ere  wri t t en as :
Qu e ry [   Iden tity / * T otal
  ,   "a "    /*  I d enti ty   ] 

... me ntall y  separating ou t  the ascendin g  a n d  d e scen din g phases.
Q uery Oper ator s  v s.N ormal  Oper at o rs Throughout this res po nse, t herehas been an i mplicit di s t i nction d rawn be t ween query ope rator s and thef unctions  that  impleme nt them.T his is a n i mpo rta ntd i st inction to re a l ize.  It is j ust  a coin cid enc e t hat  t he Totalquery op er at or  i s i mplem e nted byth e l ik e-n amedT otal f uncti on. T hi s  co inciden c ei s  not  t ru e in  ge ne ral. Wea lre ady saw  exceptio nsl ike"a "interpr eted as Key[" a" ] and 1;;5  i nte rprete d as #[[1; ;5]]&.
GroupBy is an ex a mple of  aquery  ope rator tha t b ehaves  su b tly di fferen tly f ro m i t s  func t i on  na me sake.  Gro u p By[ "a"]is  qui etly re written as GroupBy [ Key ["a"]].  Ther e a re m a n yoth e ro per at o rst h at have similar  small cha ng e sin behavio u r - -study t he docu menta t ion for  details. 
Here isan  int e r est ing case:the /* q uery oper a tor b e ha ves v ery  diffe re ntl y fro m the/ * f uncti on.  T he  /* fu nctio nsimply c hains operations togeth er, on e rig htafter the  ot h er.   But the  lef t and righ t o per ation s o f  the/* q u er y o p erato r wi l l not nec e ss ari l y  b e executedo n e  ri ght a fte r  the o ther  -- they might be separated by m anyi n ter ven i ng o pe rators from lo wer  q u e ry level s.   Don't befooled b yt he su rfacesimila rity of t he syntax .  C ons ider:
Que ry[ Se l ect[Odd Q]  / *  f, Se lect [E venQ]/* g]/ / No r m al

(* Select[Od dQ] / * Map[S e lec t[Eve nQ ] /* g] /* f  *)

Notic e how the o perand s fr om Se lect[Od dQ ] /*
 roughly_equivalent substitutes_used to avoid distracting_from the_main_points of_discussion.
To_see the actual_interpretation of a_query, use Normal:
Query[(1 ;;_5) /* Total,_"a"]_// Normal

(* GeneralUtilities`Slice[1 ;; 5] /* GeneralUtilities`Slice[All, "a"] /* Total *)

GeneralUtilities`Slice is a common_query_helper function_that_can_perform all manner of slicing_and mapping functions, applied simultaneously.
I_recommend thinking_in such notional terms, with query operators operating_upon_distinct expression levels_with distinct descending and ascending phases.  It helps_that the documentation is written in_such terms, and_the_optimized_execution plans respect those_semantics.  Make it a habit_to read the query:
Query[Total, "a"]

as if_it were written as:
Query[   Identity_ /*  Total
  _ ,   "a"_ _    /*_ Identity _ ]

..._mentally separating out_the ascending and descending phases.
Query Operators_vs. Normal Operators
Throughout_this response, there has been an_implicit_distinction drawn between_query_operators_and the_functions that implement_them._ This_is_an important distinction to realize. _It_is just a coincidence that the Total_query operator is implemented_by_the like-named Total function._ This coincidence is not_true in general.  We already_saw exceptions_like "a"_interpreted as Key["a"] and 1;;5 interpreted as #[[1;;5]]&.
GroupBy is an example_of a query operator that behaves_subtly differently from its_function namesake.__GroupBy["a"] is quietly_rewritten_as GroupBy[Key["a"]]._ There are many other operators that_have similar_small changes in behaviour -- study_the documentation for details.
Here_is_an interesting case: the /* query_operator behaves very differently from the_/* function.  The /*_function_simply_chains operations together, one right_after the other.  But the_left and right_operations of the /* query operator will_not_necessarily be executed one right after_the_other -- they might be separated_by_many_intervening operators from lower query_levels.  Don't be fooled by_the surface similarity of the syntax.  Consider:
Query[Select[OddQ] /*_f, Select[EvenQ] /*_g] // Normal

(* Select[OddQ] /*_Map[Select[EvenQ]_/*_g] /* f *)

Notice how the operands from Select[OddQ] /*