PHP drupal_array_merge_deep函数代码示例

 public static function discover($path, ReaderInterface $reader)
 {
     $data = array();
     $ext = $reader->getFileExtensions();
     if (empty($ext)) {
         $pattern = '*';
     } else {
         if (1 === count($ext)) {
             $pattern = '*.' . $ext;
         } else {
             $pattern = '*.{' . implode(',', $ext) . '}';
         }
     }
     foreach (glob($path . '/' . $pattern, GLOB_BRACE | GLOB_NOESCAPE) as $filename) {
         $additions = $reader->read($filename);
         // Fetch section name
         $parts = explode('.', basename($filename));
         array_pop($parts);
         $current =& $data;
         foreach ($parts as $part) {
             if (empty($current[$part])) {
                 $current[$part] = array();
             }
             $current =& $current[$part];
         }
         $current = drupal_array_merge_deep($additions, $current);
     }
     return $data;
 }

 /**
  * Constructs a DataProviderFile object.
  */
 public function __construct(RequestInterface $request, ResourceFieldCollectionInterface $field_definitions, $account, $plugin_id, $resource_path, array $options, $langcode = NULL)
 {
     parent::__construct($request, $field_definitions, $account, $plugin_id, $resource_path, $options, $langcode);
     $file_options = empty($this->options['options']) ? array() : $this->options['options'];
     $default_values = array('validators' => array('file_validate_extensions' => array(), 'file_validate_size' => array()), 'scheme' => file_default_scheme(), 'replace' => FILE_EXISTS_RENAME);
     $this->options['options'] = drupal_array_merge_deep($default_values, $file_options);
 }

 /**
  * PublicFieldInfoBase constructor.
  *
  * @param string $field_name
  *   The name of the field.
  * @param array[] $sections
  *   The array of categories information.
  */
 public function __construct($field_name, array $sections = array())
 {
     $this->fieldName = $field_name;
     $sections = drupal_array_merge_deep($this::$defaultSections, $sections);
     foreach ($sections as $section_name => $section_info) {
         $this->addCategory($section_name, $section_info);
     }
 }

 /**
  * Generate a settings form for this handler.
  */
 public function settingsForm($field, $instance)
 {
     $form['action'] = array('#type' => 'select', '#title' => t('Action'), '#options' => array('none' => t('Do nothing'), 'hide' => t('Hide field'), 'disable' => t('Disable field')), '#description' => t('Action to take when prepopulating field with values via URL.'));
     $form['action_on_edit'] = array('#type' => 'checkbox', '#title' => t('Apply action on edit'), '#description' => t('Apply action when editing an existing entity.'), '#states' => array('invisible' => array(':input[name="instance[settings][behaviors][prepopulate][action]"]' => array('value' => 'none'))));
     $form['fallback'] = array('#type' => 'select', '#title' => t('Fallback behaviour'), '#description' => t('Determine what should happen if no values are provided via URL.'), '#options' => array('none' => t('Do nothing'), 'hide' => t('Hide field'), 'form_error' => t('Set form error'), 'redirect' => t('Redirect')));
     // Get list of permissions.
     $perms = array();
     $perms[0] = t('- None -');
     foreach (module_list(FALSE, FALSE, TRUE) as $module) {
         // By keeping them keyed by module we can use optgroups with the
         // 'select' type.
         if ($permissions = module_invoke($module, 'permission')) {
             foreach ($permissions as $id => $permission) {
                 $perms[$module][$id] = strip_tags($permission['title']);
             }
         }
     }
     $form['skip_perm'] = array('#type' => 'select', '#title' => t('Skip access permission'), '#description' => t('Set a permission that will not be affected by the fallback behavior.'), '#options' => $perms);
     $form['providers'] = array('#type' => 'container', '#theme' => 'entityreference_prepopulate_providers_table', '#element_validate' => array('entityreference_prepopulate_providers_validate'));
     $providers = entityreference_prepopulate_providers_info();
     // Sort providers by weight.
     $providers_names = !empty($instance['settings']['behaviors']['prepopulate']['providers']) ? array_keys($instance['settings']['behaviors']['prepopulate']['providers']) : array();
     $providers_names = drupal_array_merge_deep($providers_names, array_keys($providers));
     $weight = 0;
     foreach ($providers_names as $name) {
         // Validate that the provider exists.
         if (!isset($providers[$name])) {
             continue;
         }
         $provider = $providers[$name];
         // Set default values.
         $provider += array('disabled' => FALSE);
         $form['providers']['title'][$name] = array('#type' => 'item', '#markup' => filter_xss($provider['title']), '#description' => filter_xss($provider['description']));
         if (!isset($instance['settings']['behaviors']['prepopulate']['providers'][$name])) {
             // backwards compatibility with version 1.4.
             if ($name == 'url') {
                 // Enable the URL provider is it is not set in the instance yet.
                 $default_value = TRUE;
             } elseif ($name == 'og_context') {
                 $default_value = !empty($instance['settings']['behaviors']['prepopulate']['og_context']);
             }
         } else {
             $default_value = !empty($instance['settings']['behaviors']['prepopulate']['providers'][$name]);
         }
         $form['providers']['enabled'][$name] = array('#type' => 'checkbox', '#disabled' => $provider['disabled'], '#default_value' => $default_value);
         $form['providers']['weight'][$name] = array('#type' => 'weight', '#default_value' => $weight, '#attributes' => array('class' => array('provider-weight')));
         ++$weight;
     }
     return $form;
 }

  /**
   * Overrides \RestfulEntityBase::__construct()
   *
   * Set the "options" key from the plugin info, specific for file upload, with
   * the following keys:
   * - "validators": By default no validation is done on the file extensions or
   *   file size.
   * - "scheme": By default the default scheme (e.g. public, private) is used.
   */
  public function __construct(array $plugin, \RestfulAuthenticationManager $auth_manager = NULL, \DrupalCacheInterface $cache_controller = NULL, $language = NULL) {
    parent::__construct($plugin, $auth_manager, $cache_controller, $language);

    if (!$options = $this->getPluginKey('options')) {
      $options = array();
    }

    $default_values = array(
      'validators' => array(
        'file_validate_extensions' => array(),
        'file_validate_size' => array(),
      ),
      'scheme' => file_default_scheme(),
      'replace' => FILE_EXISTS_RENAME,
    );

    $this->setPluginKey('options', drupal_array_merge_deep($default_values, $options));
  }

 protected function parseFile($source, $filename, $ret, &$loaded = [], Context $context)
 {
     $type = null;
     if (isset($loaded[$source])) {
         return $ret;
     }
     $loaded[$source] = true;
     if (!is_dir($filename) && !is_file($filename)) {
         throw new \InvalidArgumentException(sprintf("%s: file does not exists", $filename));
     }
     $timer = $context->time('parse:' . $source);
     if (!empty($type)) {
         $readerClass = '\\USync\\Parsing\\' . ucfirst($type) . 'Reader';
         if (!class_exists($readerClass)) {
             throw new \InvalidArgumentException(sprintf("'%s': type is not supported", $type));
         }
         $reader = new $readerClass();
     } else {
         $reader = new YamlReader();
     }
     if (is_file($filename)) {
         $data = $reader->read($filename);
     } else {
         if (is_dir($filename)) {
             $discovery = new PathDiscovery();
             $data = $discovery->discover($filename, $reader);
         }
     }
     if (empty($data)) {
         throw new \RuntimeException(sprintf("%s: Could not parse file or folder", $filename));
     }
     foreach ($this->findDependencies($filename, $data) as $depSource => $depFilename) {
         $ret = $this->parseFile($depSource, $depFilename, $ret, $loaded, $context);
     }
     $timer->stop();
     return drupal_array_merge_deep($ret, $data);
 }

//.........这里部分代码省略.........
         $extra_post .= '&' . urlencode('ajax_html_ids[]') . '=' . urlencode($id);
     }
     if (isset($drupal_settings['ajaxPageState'])) {
         $extra_post .= '&' . urlencode('ajax_page_state[theme]') . '=' . urlencode($drupal_settings['ajaxPageState']['theme']);
         $extra_post .= '&' . urlencode('ajax_page_state[theme_token]') . '=' . urlencode($drupal_settings['ajaxPageState']['theme_token']);
         foreach ($drupal_settings['ajaxPageState']['css'] as $key => $value) {
             $extra_post .= '&' . urlencode("ajax_page_state[css][{$key}]") . '=1';
         }
         foreach ($drupal_settings['ajaxPageState']['js'] as $key => $value) {
             $extra_post .= '&' . urlencode("ajax_page_state[js][{$key}]") . '=1';
         }
     }
     // Unless a particular path is specified, use the one specified by the
     // Ajax settings, or else 'system/ajax'.
     if (!isset($ajax_path)) {
         $ajax_path = isset($ajax_settings['url']) ? $ajax_settings['url'] : 'system/ajax';
     }
     // Submit the POST request.
     $return = drupal_json_decode($this->drupalPost(NULL, $edit, array('path' => $ajax_path, 'triggering_element' => $triggering_element), $options, $headers, $form_html_id, $extra_post));
     // Change the page content by applying the returned commands.
     if (!empty($ajax_settings) && !empty($return)) {
         // ajax.js applies some defaults to the settings object, so do the same
         // for what's used by this function.
         $ajax_settings += array('method' => 'replaceWith');
         // DOM can load HTML soup. But, HTML soup can throw warnings, suppress
         // them.
         $dom = new DOMDocument();
         @$dom->loadHTML($content);
         // XPath allows for finding wrapper nodes better than DOM does.
         $xpath = new DOMXPath($dom);
         foreach ($return as $command) {
             switch ($command['command']) {
                 case 'settings':
                     $drupal_settings = drupal_array_merge_deep($drupal_settings, $command['settings']);
                     break;
                 case 'insert':
                     $wrapperNode = NULL;
                     // When a command doesn't specify a selector, use the
                     // #ajax['wrapper'] which is always an HTML ID.
                     if (!isset($command['selector'])) {
                         $wrapperNode = $xpath->query('//*[@id="' . $ajax_settings['wrapper'] . '"]')->item(0);
                     } elseif (in_array($command['selector'], array('head', 'body'))) {
                         $wrapperNode = $xpath->query('//' . $command['selector'])->item(0);
                     }
                     if ($wrapperNode) {
                         // ajax.js adds an enclosing DIV to work around a Safari bug.
                         $newDom = new DOMDocument();
                         $newDom->loadHTML('<div>' . $command['data'] . '</div>');
                         $newNode = $dom->importNode($newDom->documentElement->firstChild->firstChild, TRUE);
                         $method = isset($command['method']) ? $command['method'] : $ajax_settings['method'];
                         // The "method" is a jQuery DOM manipulation function. Emulate
                         // each one using PHP's DOMNode API.
                         switch ($method) {
                             case 'replaceWith':
                                 $wrapperNode->parentNode->replaceChild($newNode, $wrapperNode);
                                 break;
                             case 'append':
                                 $wrapperNode->appendChild($newNode);
                                 break;
                             case 'prepend':
                                 // If no firstChild, insertBefore() falls back to
                                 // appendChild().
                                 $wrapperNode->insertBefore($newNode, $wrapperNode->firstChild);
                                 break;
                             case 'before':
                                 $wrapperNode->parentNode->insertBefore($newNode, $wrapperNode);

 public function synchronize(NodeInterface $node, Context $context, $dirtyAllowed = false)
 {
     /* @var $node ViewNode */
     $entityType = $node->getEntityType();
     $bundle = $node->getBundle();
     $name = $node->getName();
     // First populate the variable that will be used during the
     // hook_entity_info_alter() call to populate the view modes
     $viewModes = variable_get(USYNC_VAR_VIEW_MODE, []);
     $viewModes[$entityType][$name] = $name;
     variable_set(USYNC_VAR_VIEW_MODE, $viewModes);
     // First grab a list of everything that can be displayed in view
     // modes with both extra fields and real fields
     $instances = field_info_instances($entityType, $bundle);
     $bundleSettings = field_bundle_settings($entityType, $bundle);
     $extra = $this->getExtraFieldsDisplay($entityType, $bundle);
     $weight = 0;
     $displayExtra = [];
     $displayField = [];
     // Then deal with fields and such
     foreach ($node->getValue() as $propertyName => $formatter) {
         if (isset($instances[$propertyName])) {
             $display = array();
             // We are working with a field
             if (!is_array($formatter)) {
                 if (true === $formatter || 'default' === $formatter) {
                     $formatter = array();
                 } else {
                     if (false === $formatter || null === $formatter || 'delete' === $formatter) {
                         continue;
                     } else {
                         if (!is_string($formatter)) {
                             $context->logWarning(sprintf("%s: %s invalid value for formatter", $node->getPath(), $propertyName));
                             $formatter = array();
                         } else {
                             $display['type'] = $formatter;
                         }
                     }
                 }
             } else {
                 $display = $formatter;
             }
             // Merge default and save
             $displayField[$propertyName] = drupal_array_merge_deep($this->getFieldDefault($node, $entityType, $bundle, $propertyName, $context), $display, array('weight' => $weight++));
         } else {
             if (isset($extra[$propertyName])) {
                 // We are working with and extra field
                 if (!is_array($formatter)) {
                     if (true === $formatter || 'default' === $formatter) {
                         $formatter = array();
                     } else {
                         if (false === $formatter || null === $formatter || 'delete' === $formatter) {
                             continue;
                         } else {
                             $context->logWarning(sprintf("%s: %s extra fields can only be delete or default", $node->getPath(), $propertyName));
                         }
                     }
                 }
                 // Merge default and save
                 $displayExtra[$propertyName] = ['visible' => true, 'weight' => $weight++];
             } else {
                 $context->logError(sprintf("%s: %s property is nor a field nor an extra field", $node->getPath(), $propertyName));
             }
         }
     }
     // Iterate over the fields and update each instance: we don't
     // need to do it with the $displayExtra property since it is
     // already the correctly formatted variable
     foreach ($displayField as $fieldName => $display) {
         $instances[$fieldName]['display'][$name] = $display;
     }
     // Remove non configured fields and extra fields from display
     foreach ($instances as $fieldName => $instance) {
         if (!isset($displayField[$fieldName])) {
             $instance['display'][$name] = array('type' => 'hidden');
         }
         if ($dirtyAllowed) {
             $data = $instance;
             unset($data['id'], $data['field_id'], $data['field_name'], $data['entity_type'], $data['bundle'], $data['deleted']);
             db_update('field_config_instance')->condition('id', $instance['id'])->fields(['data' => serialize($data)])->execute();
         } else {
             field_update_instance($instance);
         }
     }
     foreach (array_keys($extra) as $propertyName) {
         if (isset($displayExtra[$propertyName])) {
             $bundleSettings['extra_fields']['display'][$propertyName][$name] = $displayExtra[$propertyName];
         } else {
             $bundleSettings['extra_fields']['display'][$propertyName][$name] = ['visible' => false, 'weight' => $weight++];
         }
     }
     $bundleSettings['view_modes'][$name] = ['label' => $name, 'custom_settings' => true];
     if ($dirtyAllowed) {
         // Hopefully nothing about display is really cached into the
         // internal field cache class, except the raw display array
         // into each instance, but nothing will use that except this
         // specific view mode implementation, we are going to delay
         // a few cache clear calls at the very end of the processing.
         // From field_bundle_settings().
         variable_set('field_bundle_settings_' . $entityType . '__' . $bundle, $bundleSettings);
//.........这里部分代码省略.........

/**
 * Implements template_preprocess_node()
 */
function bht_theme_preprocess_node(&$variables)
{
    // Define default theme hook suggestion for nodes.
    // Set node--{view_mode}.tpl.php.
    $variables['theme_hook_suggestions'][] = "node__" . $variables['view_mode'];
    // Set node--{node_type}.tpl.php.
    $variables['theme_hook_suggestions'][] = "node__" . $variables['type'];
    // Set node--{node_type}--{view_mode}.tpl.php.
    $variables['theme_hook_suggestions'][] = "node__" . $variables['type'] . "__" . $variables['view_mode'];
    if ($variables['type'] == 'events' && $variables['view_mode'] == 'full' && $variables['promote']) {
        // Set node--{node_type}--{view_mode}.tpl.php.
        $variables['theme_hook_suggestions'][] = "node__" . $variables['type'] . "__" . $variables['view_mode'] . "_promoted";
    }
    // Set node--{nid}.tpl.php.
    $variables['theme_hook_suggestions'][] = "node__" . $variables['nid'];
    // Merge in any custom attributes set in the renderable array.
    if (isset($variables['node']->attributes_array) && is_array($variables['node']->attributes_array)) {
        $variables['attributes_array'] = drupal_array_merge_deep($variables['attributes_array'], $variables['node']->attributes_array);
    }
    // Replace || with <wbr> tag.
    $variables['title'] = str_replace('||', '<wbr>&shy;', $variables['title']);
}

 public static function changeInstances(array $field, array $field_instance_overrides = array())
 {
     $type_info = field_info_field_types($field['type']);
     $instances = field_read_instances(array('field_name' => $field['field_name']));
     foreach ($instances as $instance) {
         $prior_instance = $instance;
         // Serialize properties back into the data property so it can be saved
         // to the database.
         $instance['data'] = array();
         foreach ($instance as $key => $value) {
             switch ($key) {
                 case 'id':
                 case 'field_id':
                 case 'field_name':
                 case 'entity_type':
                 case 'bundle':
                 case 'deleted':
                 case 'data':
                     break;
                 default:
                     $instance['data'][$key] =& $instance[$key];
             }
         }
         $instance['settings'] = array_intersect_key($instance['settings'], $type_info['instance_settings']);
         $instance['settings'] += $type_info['instance_settings'];
         // Validate the existing widget can be used with the new field type.
         $widget_info = field_info_widget_types($instance['widget']['type']);
         if (!in_array($field['type'], $widget_info['field types'])) {
             // Fallback to using the field type's default widget.
             $instance['widget']['type'] = $type_info['default_widget'];
             $widget_info = field_info_widget_types($type_info['default_widget']);
             $instance['widget']['module'] = $widget_info['module'];
             $instance['widget']['settings'] = array_intersect_key($instance['widget']['settings'], $widget_info['settings']);
             $instance['widget']['settings'] += $widget_info['settings'];
         }
         // Validate the existing formatters can be used with the new field type.
         foreach ($instance['display'] as $view_mode => $display) {
             if ($display['type'] !== 'hidden') {
                 $formatter_info = field_info_formatter_types($display['type']);
                 if (!in_array($field['type'], $formatter_info['field types'])) {
                     // Fallback to using the field type's default formatter.
                     $instance['display'][$view_mode]['type'] = $type_info['default_formatter'];
                     $formatter_info = field_info_formatter_types($type_info['default_formatter']);
                     $instance['display'][$view_mode]['module'] = $formatter_info['module'];
                     $instance['display'][$view_mode]['settings'] = array_intersect_key($instance['display'][$view_mode], $formatter_info['settings']);
                     $instance['display'][$view_mode]['settings'] += $formatter_info['settings'];
                 }
             }
         }
         // Allow anything to be overridden before it gets saved.
         $instance = drupal_array_merge_deep($instance, $field_instance_overrides);
         drupal_write_record('field_config_instance', $instance, array('id'));
         // Clear caches.
         field_cache_clear();
         module_invoke_all('field_update_instance', $instance, $prior_instance);
     }
 }

 /**
  * Retrieves the git clone settings.
  *
  * @return array|string
  *   The settings array or serialized string (depending on the original state
  *   it was in).
  */
 public function getSettings()
 {
     $settings = array();
     if (!isset($this->settings)) {
         $this->settings = array();
     }
     // Since the settings property can be both an array or a serialized string
     // (depending on the current point in the Entity API process), the
     // serialized string must be checked for, converted to and array, merged
     // with defaults and converted back to a serialized string.
     $serialized = FALSE;
     if (is_string($this->settings)) {
         if ($settings = unserialize($this->settings)) {
             $serialized = TRUE;
         } else {
             $settings = array();
         }
     } elseif (is_array($this->settings)) {
         $settings = $this->settings;
     }
     // Merge in default settings.
     $defaults = array('default' => NULL, 'fetch_threshold' => 3600);
     $settings = drupal_array_merge_deep($defaults, $settings);
     // Return the correct format.
     return $this->settings = $serialized ? serialize($settings) : $settings;
 }

<?php

// Merge in any custom attributes set in the renderable array.
if (isset($node->attributes_array) && is_array($node->attributes_array)) {
    $attributes_array = drupal_array_merge_deep($attributes_array, $node->attributes_array);
}
$attributes_array['class'][] = 'sponsor__item';
if ($sticky) {
    $attributes_array['class'][] = 'sticky';
}
?>

<div <?php 
print drupal_attributes($attributes_array);
?>
>
  <?php 
print render($content);
?>
</div>

  /**
   * Call resource using the OPTIONS http method.
   *
   * This is an special method since it does not return anything in the body, it
   * only provides information about the selected endpoint. The information is
   * provided via HTTP headers.
   *
   * @param string $path
   *   (optional) The path.
   * @param array $request
   *   (optional) The request.
   *
   * @return array
   *   Information about the fields in the current resource.
   */
  public function options($path = '', array $request = array()) {
    $this->setMethod(\RestfulInterface::OPTIONS);
    $this->setPath($path);
    $this->setRequest($request);
    // A list of discoverable methods.
    $allowed_methods = array();
    foreach ($this->getControllers() as $pattern => $controllers) {
      // Find the controllers for the provided path.
      if ($pattern != $path && !($pattern && preg_match('/' . $pattern . '/', $path))) {
        continue;
      }
      $allowed_methods = array_keys($controllers);
      // We have found the controllers for this path.
      break;
    }
    if (!empty($allowed_methods)) {
      $this->setHttpHeaders('Access-Control-Allow-Methods', implode(',', $allowed_methods));
    }

    // Make your formatters discoverable.
    $formatter_names = $this->formatterNames();
    // Loop through all the formatters and add the Content-Type header to the
    // array.
    $accepted_formats = array();
    foreach ($formatter_names as $formatter_name) {
      $formatter = restful_get_formatter_handler($formatter_name, $this);
      $accepted_formats[] = $formatter->getContentTypeHeader();
    }
    if (!empty($accepted_formats)) {
      $this->setHttpHeaders('Accept', implode(',', $accepted_formats));
    }

    $output = array();
    // Default options for the discovery information.
    $discovery_defaults = array(
      'info' => array(
        'label' => '',
        'description' => '',
      ),
      // Describe the data.
      'data' => array(
        'type' => NULL,
        'read_only' => FALSE,
        'cardinality' => 1,
        'required' => FALSE,
      ),
      // Information about the form element.
      'form_element' => array(
        'type' => NULL,
        'default_value' => '',
        'placeholder' => '',
        'size' => NULL,
        'allowed_values' => NULL,
      ),
    );

    foreach ($this->getPublicFields() as $public_field => $field_info) {
      if (empty($field_info['discovery'])) {
        continue;
      }
      $output[$public_field] = drupal_array_merge_deep($discovery_defaults, $field_info['discovery']);
    }
    return $output;

  }

<?php

// This function is invoked as theme wrapper, but the rendered form element
// may not necessarily have been processed by form_builder().
$element['#title_display'] = 'before';
if (!isset($attributes_array)) {
    $attributes_array = array();
}
if (!empty($element['#attributes_array'])) {
    $attributes_array = drupal_array_merge_deep($attributes_array, $element['#attributes_array']);
}
// Add element #id for #type 'item'.
if (isset($element['#markup']) && !empty($element['#id'])) {
    $attributes_array['id'] = $element['#id'];
}
// Add element's #type and #name as class to aid with JS/CSS selectors.
$attributes_array['class'][] = 'form-item';
$attributes_array['class'][] = 'register';
$attributes_array['class'][] = 'js-chk-dynamic';
if (!empty($element['#type'])) {
    $attributes_array['class'][] = 'form-type-' . strtr($element['#type'], '_', '-');
}
if (!empty($element['#name'])) {
    $attributes_array['class'][] = 'form-item-' . strtr($element['#name'], array(' ' => '-', '_' => '-', '[' => '-', ']' => ''));
}
// Add a class for disabled elements to facilitate cross-browser styling.
if (!empty($element['#attributes']['disabled'])) {
    $attributes_array['class'][] = 'form-disabled';
}
// If #title is not set, we don't display any label or required marker.
if (!isset($element['#title'])) {

 public static function getAllReferencesTo($entity_type, array $entity_ids, EntityFieldQuery $query = NULL, $flatten = FALSE)
 {
     if (!isset($query)) {
         $query = new EntityFieldQuery();
         $query->addTag('DANGEROUS_ACCESS_CHECK_OPT_OUT');
     }
     $references = array();
     $fields = FieldHelper::getEntityReferencingFieldsByType($entity_type);
     foreach ($fields as $field_name => $columns) {
         foreach (array_keys($columns) as $column) {
             $field_query = clone $query;
             $field_query->fieldCondition($field_name, $column, $entity_ids);
             if ($results = $field_query->execute()) {
                 if ($flatten) {
                     $references = drupal_array_merge_deep($references, $results);
                 } else {
                     $references[$field_name . ':' . $column] = $results;
                 }
             }
         }
     }
     return $references;
 }