ગૂગલ ડ્રાઇવમાં મેટાડેટા કેવી રીતે દૂર કરવો

શું તમે તમારી ફાઇલોના મેટાડેટાને નિયંત્રિત કરવા માંગો છો Google ડ્રાઇવ અને ક્યાંથી શરૂઆત કરવી તે ખબર નથી? અહીં આપણે વિગતવાર સમજાવીએ છીએ, ગૂગલ ડ્રાઇવમાં મેટાડેટાને અસરકારક અને સુરક્ષિત રીતે કેવી રીતે દૂર કરવો (અપલોડ કરેલી ફાઇલોનો મેટાડેટા). અમે તમને એ પણ જણાવીએ છીએ કે Google ફાઇલ નામો, કદ અને પરવાનગીઓ પર કઈ મર્યાદાઓ લાદે છે.

આ માર્ગદર્શિકા તમને Google ડ્રાઇવમાં મેટાડેટાની વાત આવે ત્યારે શું "કાઢી શકાય છે" (અને શું નહીં) તેની સંપૂર્ણ અને વાસ્તવિક સમજ આપશે.

ડ્રાઇવમાં શું બદલી અથવા "ડિલીટ" કરી શકાય છે

આ છે મેટાડેટા જે Google ડ્રાઇવ પર અપલોડ કરેલી ફાઇલોમાંથી દૂર કરી શકાય છે:

નામ અને એક્સ્ટેંશન: API દ્વારા ફાઇલ બનાવતી વખતે, નામ ક્ષેત્રમાં એક્સ્ટેંશનનો ઉલ્લેખ કરવો એ સારો વિચાર છે, ઉદાહરણ તરીકે, "cat.jpg". જો તમે તેને સ્પષ્ટ ન કરો તો ડ્રાઇવ MIME પ્રકારમાંથી એક્સ્ટેંશનનું અનુમાન લગાવી શકે છે, પરંતુ તેને જાતે વ્યાખ્યાયિત કરવું વધુ સારું છે. અનુગામી પ્રતિભાવોમાં, નામમાંથી ભરેલા એક્સ્ટેંશન સાથે ફક્ત વાંચવા માટે ફાઇલએક્સટેન્શન દેખાઈ શકે છે. જો કોઈ વપરાશકર્તા ફાઇલ ડાઉનલોડ કરે છે, તો ડ્રાઇવ શીર્ષક (અને તેના એક્સ્ટેંશન) માંથી અંતિમ નામ કમ્પાઇલ કરે છે.

• ઇન્ડેક્સેબલ ટેક્સ્ટ (contentHints.indexableText): ડ્રાઇવ ડિફૉલ્ટ રૂપે સામાન્ય દસ્તાવેજો અને પ્રકારો (PDF, OCR-સક્ષમ છબીઓ, વગેરે) ને અનુક્રમિત કરે છે. જો તમારી એપ્લિકેશન અન્ય ફોર્મેટ (ડ્રોઇંગ્સ, વિડિઓઝ, શોર્ટકટ્સ) સાચવે છે, તો તમે શોધને સુધારવા માટે અનુક્રમિત ટેક્સ્ટ પ્રદાન કરી શકો છો. આ ટેક્સ્ટને HTML તરીકે પ્રક્રિયા કરવામાં આવે છે: જો તમે ટૅગ્સ ધરાવતી સ્ટ્રિંગ પસાર કરો છો, તો ટેક્સ્ટ સામગ્રીને અનુક્રમિત કરવામાં આવે છે, ટેગ વિશેષતાઓને નહીં. contentHints.indexableText માટે 128KB કદ મર્યાદા છે, અને ભલામણ કરવામાં આવે છે કે તમે તેને દરેક સેવ પર અપડેટ કરો અને તેને ફાઇલ સાથે સંબંધિત રાખો.
• થંબનેલ્સ (contentHints.thumbnail): ડ્રાઇવ ઘણા પ્રકારો માટે થંબનેલ્સ જનરેટ કરે છે, પરંતુ જે ફોર્મેટ આપમેળે જનરેટ થતા નથી, તે ફોર્મેટ માટે તમે ફાઇલ બનાવતી વખતે અથવા અપડેટ કરતી વખતે તમારા પોતાના અપલોડ કરી શકો છો. તમારે છબીને URL-સેફ base64 અને અનુરૂપ mimeType પર સેટ કરવી આવશ્યક છે. મુખ્ય નિયમો: સમર્થિત ફોર્મેટ PNG, GIF, અથવા JPG છે; ભલામણ કરેલ પહોળાઈ 1600px (ઓછામાં ઓછી 220px) છે, અને મહત્તમ કદ 2MB છે. ફાઇલ સામગ્રી બદલાય ત્યારે થંબનેલ્સ અમાન્ય થઈ જાય છે; મેટાડેટા ફેરફારો થતા નથી.
• થંબનેલ્સની ઍક્સેસ: થંબનેલલિંક ફીલ્ડ એક ટૂંકું URL આપે છે, જે ફક્ત ત્યારે જ ઍક્સેસિબલ હોય છે જો એપ્લિકેશન પાસે ફાઇલ વાંચવાની પરવાનગી હોય (જો તે સાર્વજનિક ન હોય, તો તમારે તેને ઓળખપત્રો સાથે વિનંતી કરવાની જરૂર પડશે). તમે તેને ચોક્કસ ફાઇલ માટે અથવા પ્રકાર દ્વારા ફિલ્ટર કરેલી સૂચિ માટે ક્વેરી કરી શકો છો.
• લેબલ્સ: ડ્રાઇવ તમને લેબલ્સને ફાઇલો સાથે સાંકળવાની મંજૂરી આપે છે. તેમને શોધવા માટે, તમે files.listLabels નો ઉપયોગ કરી શકો છો, અને તેમને સુધારવા માટે, તમારે સંબંધિત labelId અને fileId નો સંદર્ભ લેવો આવશ્યક છે. આ પદ્ધતિ સામગ્રીને સ્પર્શ કર્યા વિના અનિચ્છનીય વર્ગીકરણોને વર્ગીકૃત કરવા અને જો જરૂરી હોય તો "સાફ" કરવા માટે ઉપયોગી છે.

ગૂગલ ડ્રાઇવમાંથી મેટાડેટા કાઢી નાખો: ફાઇલમાંથી જ "છુપાયેલ" મેટાડેટા

ગૂગલ ડ્રાઇવમાં મેટાડેટા દૂર કરવા માટે કોઈ જાદુઈ બટન નથી (જેમ કે ફોટામાં EXIF ​​અથવા PDF માં એમ્બેડેડ ડેટા). ડ્રાઇવ તેના પોતાના મેટાડેટાનું સંચાલન કરે છે, પરંતુ ફાઇલમાં મેટાડેટા તે ટૂલ પર આધાર રાખે છે જેણે તેને બનાવ્યું છે.

ભલામણ કરેલ પ્રથા છે ડ્રાઇવ પર અપલોડ કરતા પહેલા ફાઇલને સાફ કરો, સિસ્ટમ ટૂલ્સ અથવા વિશિષ્ટ એપ્લિકેશનોનો ઉપયોગ કરીને જે છબીઓ અથવા દસ્તાવેજ ગુણધર્મોમાંથી EXIF ​​ડેટા દૂર કરે છે. આ રીતે, તમે ડ્રાઇવમાં સાચવેલી સામગ્રી "સ્વચ્છ" થાય છે.

જો તમારી પાસે પહેલાથી જ એમ્બેડેડ મેટાડેટા સાથે ફાઇલો અપલોડ કરેલી હોય, તો Google ડ્રાઇવમાંથી મેટાડેટા દૂર કરવાને બદલે, તે વધુ અનુકૂળ છે. ડાઉનલોડ કરો, સાફ કરો અને ફરીથી અપલોડ કરો, જો લાગુ પડતું હોય તો મૂળને બદલીને. PDF અથવા છબીઓ સાથે, જ્યારે તમે લેખકત્વ, સ્થાન અથવા સંપાદન ઇતિહાસને સુરક્ષિત કરવા માંગતા હો ત્યારે આ સામાન્ય છે.

ડ્રાઇવના ચોક્કસ ભાગ માટે, નામ, લેબલ્સ અને કન્ટેન્ટહિન્ટ્સ (ઇન્ડેક્સેબલ ટેક્સ્ટ/થંબનેલ) ને સમાયોજિત કરવા પર ધ્યાન કેન્દ્રિત કરો, જે તમારા નિયંત્રણ હેઠળ છે. જો તમે ઍક્સેસ પરવાનગીઓનું પણ સંચાલન કરો છો, તો તમે દૃશ્યમાન મેટાડેટા (ઉદાહરણ તરીકે, વાંચન અધિકારો ધરાવતા લોકો માટે સુલભ થંબનેલ લિંક્સ) ના સંપર્કમાં પણ ઘટાડો કરો છો.

તે ભૂલશો નહીં ફક્ત ડ્રાઇવ મેટાડેટા બદલવાથી EXIF ​​અથવા આંતરિક ગુણધર્મો દૂર થતા નથી. તેથી, તમારી વ્યૂહરચનામાં ફાઇલને પ્રી-ક્લીનિંગ સાથે ઝીણા મેટાડેટા મેનેજમેન્ટને જોડવું જોઈએ જેને ડ્રાઇવ તમને સ્પર્શ કરવાની મંજૂરી આપે છે.

ગૂગલ ક્લાઉડમાં સામાન્ય રીતે ગૂંચવાયેલા મેટાડેટા: VM, gcloud અને મર્યાદાઓ

જો તમે ગૂગલ ક્લાઉડ સાથે કામ કરો છો, તો તમને ઘણા બધા દેખાશે "મેટાડેટા" વિશે માર્ગદર્શિકાઓ જે ખરેખર કમ્પ્યુટ એન્જિન અથવા ક્લાઉડ સ્ટોરેજનો સંદર્ભ આપે છે, ડ્રાઇવનો નહીં. તેમ છતાં, તમારે આ મુદ્દાઓ જાણવાની જરૂર પડશે જેથી સંશોધન કરતી વખતે તમે તેમાં ગૂંચવણ ન કરો.

મૂળભૂત gcloud CLI રૂપરેખાંકન

ગૂગલ ક્લાઉડ CLI ઇન્સ્ટોલ કર્યા પછી, આનાથી પ્રારંભ કરો:

gcloud init

તમારી પાસે નવીનતમ સંસ્કરણ છે તેની ખાતરી કરવી મહત્વપૂર્ણ છે:

gcloud components update

જો તમે બાહ્ય ઓળખ પ્રદાતાનો ઉપયોગ કરો છો, gcloud સાથે કામ કરતા પહેલા તમારી ફેડરેટેડ ઓળખ સાથે સાઇન ઇન કરો, ખાસ કરીને જો તમે તમારા સ્થાનિક વાતાવરણમાંથી REST કૉલ્સ કરવા માટે પ્રમાણીકરણ કરવા જઈ રહ્યા છો. REST API નમૂનાઓ gcloud માં તમે ગોઠવેલા ઓળખપત્રોનો ઉપયોગ કરી શકે છે.

વી.એમ.

પરવાનગીઓ અને ભૂમિકાઓ (કમ્પ્યુટ એન્જિન): VM પર કસ્ટમ મેટાડેટા ઉમેરવા, અપડેટ કરવા અથવા કાઢી નાખવા માટે, તમારે યોગ્ય IAM પરવાનગીઓની જરૂર છે. સામાન્ય ઉદાહરણોમાં શામેલ છે:

• જો તમારા VM સેવા એકાઉન્ટનો ઉપયોગ કરે છે: પરવાનગી iam.serviceAccounts.actAs સેવા અથવા પ્રોજેક્ટ ખાતામાં.
• પ્રોજેક્ટ મેટાડેટા: compute.projects.get y compute.projects.setCommonInstanceMetadata.
• ઝોનલ મેટાડેટા: compute.instanceSettings.get y compute.instanceSettings.update સંબંધિત વિસ્તાર માટે.
• ઇન્સ્ટન્સ મેટાડેટા: compute.instances.get y compute.instances.setMetadata.

મર્યાદાઓ

ગૂગલ ડ્રાઇવમાં મેટાડેટા દૂર કરવાનો પ્રયાસ કરતી વખતે અમને જે મુખ્ય મર્યાદાઓનો સામનો કરવો પડ્યો તે આ છે:

• કદ મર્યાદાઓ (કમ્પ્યુટ એન્જિન): મેટાડેટા એન્ટ્રીઓની કુલ સંખ્યા 512 KB સુધી મર્યાદિત છે. દરેક કી 128 બાઇટ્સ સુધી મર્યાદિત છે, અને દરેક મૂલ્ય 256 KB સુધી મર્યાદિત છે. ઉદાહરણ તરીકે, જો તમે ssh-keys કીનો ઉપયોગ કરો છો અને 256 KB મર્યાદા ઓળંગી જાઓ છો, તો તમે સાફ ન કરો ત્યાં સુધી વધુ કી ઉમેરી શકશો નહીં.
• અપર કેસ અને લોઅર કેસ: કી કેસ-સેન્સિટિવ હોય છે; બુલિયન સિવાય મૂલ્યો પણ ખૂબ જ હોય ​​છે. ઝોનલમાં, તમે બે કી બનાવી શકતા નથી જે ફક્ત કેસમાં અલગ હોય (ઝોનલ-મેટાડેટા-કી વિ. ઝોનલ-મેટાડેટા-કી).
• ઝોનલ મેટાડેટા: gcloud અથવા REST નો ઉપયોગ કરીને સેટ અથવા દૂર કરવામાં આવે છે. તમે SSH કી (ssh-keys) માટે ઝોનલ મૂલ્યો વ્યાખ્યાયિત કરી શકતા નથી. લોજિકલ પ્રોજેક્ટ/ ડિરેક્ટરીમાં, જો સમાન કી માટે પ્રોજેક્ટ-લેવલ અને ઝોનલ મૂલ્યો હોય, તો ઝોનલ મૂલ્ય તેના ઝોનમાં અગ્રતા લે છે.
• સમર્થિત બુલિયન મૂલ્યો: TRUE/FALSE ઉપરાંત, તમે Y/Yes/1 અને N/No/0 (કેસ અસંવેદનશીલ) નો ઉપયોગ કરી શકો છો.
• રૂપરેખાંકન અવકાશ (કમ્પ્યુટ એન્જિન):
  • ડ્રાફ્ટ: પ્રોજેક્ટમાં બધા VM માટે સામાન્ય મેટાડેટા.
  • ઝોનલ: એવી એન્ટ્રીઓ જે ચોક્કસ ઝોનમાં બધા VM ને અસર કરે છે અને પ્રોજેક્ટ મૂલ્યને ઓવરરાઇડ કરી શકે છે.
  • ઉદાહરણ: ચોક્કસ VM માટે મેટાડેટા (બનાવી રહ્યું છે અથવા પહેલાથી અસ્તિત્વમાં છે).

ડ્રાઇવમાં થંબનેલ્સ, ઇન્ડેક્સિંગ અને મેટાડેટા પુનઃપ્રાપ્તિ (REST અને શ્રેષ્ઠ પ્રથાઓ)

ચાલો હવે ગૂગલ ડ્રાઇવમાં મેટાડેટા દૂર કરતી વખતે થંબનેલ્સની ભૂમિકા જોઈએ. અને તેમને પુનઃપ્રાપ્ત કરવાની શ્રેષ્ઠ રીત પણ:

• REST ઓન-પ્રિમાઇસિસ માટે પ્રમાણીકરણ: જો તમે તમારા મશીનમાંથી REST ઉદાહરણોનું પરીક્ષણ કરી રહ્યા છો, તો gcloud સાથે ગોઠવેલા ઓળખપત્રોનો ઉપયોગ કરો. આ રીતે, તમારા ડ્રાઇવ API કૉલ્સ તમે પહેલાથી સેટ કરેલી ઓળખ અને પરવાનગીઓનો આદર કરશે.
• કસ્ટમ થંબનેલ અપલોડ: contentHints.thumbnail ને બે ફીલ્ડ સાથે સેટ કરો: URL-સેફ base64 ઇમેજ અને સાચો mimeType. જો ડ્રાઇવ આપમેળે થંબનેલ જનરેટ કરી શકે છે, તો તે પોતાનો થંબનેલ ઉપયોગ કરશે અને તમારા થંબનેલને છોડી દેશે. નહિંતર, તે તમે આપેલા થંબનેલનો ઉપયોગ કરશે.

ડ્રાઇવમાં થંબનેલ્સ માટેના મુખ્ય નિયમો:

• ફોર્મેટ્સ: PNG, GIF અથવા JPG.
• ભલામણ કરેલ પહોળાઈ: ૧૬૦૦ પિક્સેલ (ઓછામાં ઓછી ૨૨૦ પિક્સેલ).
• મહત્તમ કદ: 2MB.
• જો થંબનેલ હજુ પણ સુસંગત હોય તો દરેક સેવ સાથે તેને અપડેટ કરો.

વિશે મહત્વપૂર્ણ અમાન્યતા: ફાઇલની સામગ્રી બદલાય ત્યારે થંબનેલ્સ અમાન્ય થઈ જાય છે; મેટાડેટામાં ફેરફાર થતો નથી. જો તમે ફક્ત ટૅગ્સ અથવા નામ બદલો છો, તો જ્યાં સુધી તમે ફાઇલમાં ફેરફાર ન કરો ત્યાં સુધી નવા થંબનેલની અપેક્ષા રાખશો નહીં.

અનુક્રમણિકા યોગ્ય ટેક્સ્ટ

બઝવર્ડ્સ વડે શોધને "મૂર્ખ" બનાવવાનો પ્રયાસ કરશો નહીં. વપરાશકર્તા તે ફાઇલ માટે વાજબી રીતે શોધ કરશે તેવા ખ્યાલો અને શબ્દો કેપ્ચર કરો, અને ૧૨૮KB મર્યાદા તપાસો. જ્યારે પણ સામગ્રીમાં નોંધપાત્ર ફેરફાર થાય ત્યારે તેને અપડેટ કરો.

સુસંગત નામો અને એક્સટેન્શન લાગુ કરોશક્ય હોય ત્યારે, અપલોડ કરતી વખતે નામમાં એક્સ્ટેંશનનો સમાવેશ કરો; જો તે ખૂટે છે, તો ડ્રાઇવ તેને MIME દ્વારા અનુમાન કરવાનો પ્રયાસ કરશે. નામો સ્પષ્ટ રાખવાથી અસ્પષ્ટતા ટાળશે અને એક્સ્ટેંશન શોધને સરળ બનાવશે.

ડ્રાઇવમાં ટૅગ્સ

લેબલ્સમાં ફેરફાર કરવા માટે, જરૂરી ઓળખકર્તાઓ નોંધો. તમારે લેબલના લેબલઆઈડી અને ફાઇલના ફાઇલઆઈડીની જરૂર પડશે. તમે પહેલા તેમને files.listLabels સાથે સૂચિબદ્ધ કરી શકો છો અને પછી લક્ષ્ય ફાઇલમાં અનુરૂપ ફેરફારો લાગુ કરી શકો છો.

// Al modificar etiquetas de un archivo en Drive:
// - labelId: identificador de la etiqueta a cambiar
// - fileId: identificador del archivo al que aplicas la etiqueta
// Usa files.listLabels para localizarlas antes de actualizar.

યાદ રાખો કે, ડ્રાઇવ પર ધ્યાન કેન્દ્રિત હોવા છતાં, ઘણા વિકાસ ડ્રાઇવને ક્લાઉડ સ્ટોરેજ અથવા અન્ય સેવાઓ સાથે જોડે છે, તેથી તમને ઑબ્જેક્ટ એટ્રીબ્યુટ્સનું નિરીક્ષણ કરવા માટે સ્ટોરેજના ઉદાહરણો દેખાશે.

// Ejemplo en Go para obtener atributos de un objeto en Cloud Storage (no Drive)
// e imprimir metadatos como ContentType, CacheControl, MD5, etc.
// Útil si tu flujo sube primero a Storage y luego a Drive.
import (
  "context"
  "fmt"
  "io"
  "time"
  "cloud.google.com/go/storage"
)

func getMetadata(w io.Writer, bucket, object string) (*storage.ObjectAttrs, error) {
  ctx := context.Background()
  client, err := storage.NewClient(ctx)
  if err != nil { return nil, fmt.Errorf("storage.NewClient: %w", err) }
  defer client.Close()

  ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
  defer cancel()

  o := client.Bucket(bucket).Object(object)
  attrs, err := o.Attrs(ctx)
  if err != nil { return nil, fmt.Errorf("Object(%q).Attrs: %w", object, err) }

  fmt.Fprintf(w, "Bucket: %v\n", attrs.Bucket)
  fmt.Fprintf(w, "CacheControl: %v\n", attrs.CacheControl)
  fmt.Fprintf(w, "ContentDisposition: %v\n", attrs.ContentDisposition)
  fmt.Fprintf(w, "ContentEncoding: %v\n", attrs.ContentEncoding)
  fmt.Fprintf(w, "ContentLanguage: %v\n", attrs.ContentLanguage)
  fmt.Fprintf(w, "ContentType: %v\n", attrs.ContentType)
  fmt.Fprintf(w, "Crc32c: %v\n", attrs.CRC32C)
  fmt.Fprintf(w, "Generation: %v\n", attrs.Generation)
  fmt.Fprintf(w, "KmsKeyName: %v\n", attrs.KMSKeyName)
  fmt.Fprintf(w, "Md5Hash: %v\n", attrs.MD5)
  fmt.Fprintf(w, "MediaLink: %v\n", attrs.MediaLink)
  fmt.Fprintf(w, "Metageneration: %v\n", attrs.Metageneration)
  fmt.Fprintf(w, "Name: %v\n", attrs.Name)
  fmt.Fprintf(w, "Size: %v\n", attrs.Size)
  fmt.Fprintf(w, "StorageClass: %v\n", attrs.StorageClass)
  fmt.Fprintf(w, "TimeCreated: %v\n", attrs.Created)
  fmt.Fprintf(w, "Updated: %v\n", attrs.Updated)
  fmt.Fprintf(w, "Event-based hold enabled? %t\n", attrs.EventBasedHold)
  fmt.Fprintf(w, "Temporary hold enabled? %t\n", attrs.TemporaryHold)
  fmt.Fprintf(w, "Retention expiration time %v\n", attrs.RetentionExpirationTime)
  fmt.Fprintf(w, "Custom time %v\n", attrs.CustomTime)
  fmt.Fprintf(w, "Retention: %+v\n", attrs.Retention)
  fmt.Fprintf(w, "\n\nMetadata\n")
  for key, value := range attrs.Metadata {
    fmt.Fprintf(w, "\t%v = %v\n", key, value)
  }
  return attrs, nil
}

ગૂગલ ડ્રાઇવમાં ફાઇલો કાઢી નાખવા વિરુદ્ધ મેટાડેટા કાઢી નાખવા

જો તમારે જે જોઈએ છે તે છે ડ્રાઇવમાંથી ફાઇલ કાઢી નાખોમાલિક તરીકે, તમે તેને રાઇટ-ક્લિક કરીને અને "ટ્રેશમાં ખસેડો" પસંદ કરીને વેબ પરથી કચરાપેટીમાં ખસેડી શકો છો. જો માલિક કોઈ અન્ય હોય, તો તમે ફાઇલને ફક્ત તમારા દૃશ્યમાંથી "દૂર કરો" જ કરી શકો છો; અન્ય લોકો હજુ પણ તેને જોઈ શકશે.

પેરા ફાઇલને કાયમી ધોરણે કાઢી નાખવા માટે, તમારે કચરાપેટી ખાલી કરવી પડશે અથવા કાયમી કાઢી નાખવાના વિકલ્પનો ઉપયોગ કરવો પડશે, આ કિસ્સામાં, તમે તેને પુનઃપ્રાપ્ત કરી શકશો નહીં. આ, પોતે જ, અન્ય ફાઇલોમાંથી "મેટાડેટા દૂર" કરતું નથી - તે ફક્ત તે આઇટમ પર લાગુ પડે છે.

તમે Google ડ્રાઇવમાં તમારી માલિકીની ન હોય તેવી ફાઇલોમાંથી મેટાડેટા કાઢી શકતા નથી, કારણ કે તેમનું નિયંત્રણ તેમને બનાવનાર વ્યક્તિ અથવા સંસ્થામાં ઉચ્ચ પરવાનગીઓ ધરાવતી વ્યક્તિનું છે. આ કિસ્સાઓમાં, તમે ફક્ત તમારી ઍક્સેસ અથવા દૃશ્યતા દૂર કરો છો.

તેને મેટાડેટા સાથે સંબંધિત: ફાઇલ ડિલીટ કરવાથી ડ્રાઇવમાં તેનો મેટાડેટા તેની સાથે ડિલીટ થાય છે, પરંતુ તે અન્ય નકલોમાં મેટાડેટા અથવા સિસ્ટમમાં રહેલા અન્ય દસ્તાવેજોમાં એમ્બેડેડ મેટાડેટાને અસર કરતું નથી.

ઉપરોક્ત બધા સાથે, તમે હવે સારી રીતે તફાવત કરી શકો છો ડ્રાઇવ મેટાડેટા શું નિયંત્રિત કરે છે (નામ, ટૅગ્સ, શોધ સંકેતો અને થંબનેલ્સ), REST દ્વારા તેમને કેવી રીતે ક્વેરી કરવી, અપલોડ કરતા પહેલા એમ્બેડેડ ડેટા સાફ કરવા માટે કઈ શ્રેષ્ઠ પ્રથાઓનું પાલન કરવું, અને જ્યારે તમે Google Cloud દસ્તાવેજીકરણ જુઓ છો જે અન્ય સંદર્ભોમાં "મેટાડેટા" વિશે વાત કરે છે ત્યારે કઈ મર્યાદાઓ અને પરવાનગીઓ અમલમાં આવે છે.