Get name from underlying db node

If name is null, return node id as fallback
325962
@Override
	public final String getName() {

		String name = getProperty(AbstractNode.name);
		if (name == null) {

			name = getUuid();
		}

		return name;
	}
1054460
def getNodeByNameChain(node, chain_list):
    

    working_list = chain_list[:]
    working_list.reverse()
    current_node = node
    while len(working_list):
        current_name = working_list.pop()
        child_node = getNodeByName(current_node, current_name)
        if child_node is None:
            raise Exception("Unable to find child node %s" % current_name)
        current_node = child_node
    return current_node
722944
function getPropertyName(node) {
			if (node.computed) {
				switch (node.property.type) {
					case "Literal":
						return String(node.property.value);
					case "TemplateLiteral":
						if (node.property.expressions.length === 0) {
							return node.property.quasis[0].value.cooked;
						}
						// fallthrough
					default:
						return false;
				}
			}
			return node.property.name;
		}
25986
def __get_node_by_name(self, name):
        
        try:
            for entry in filter(lambda x: x.name == name, self.nodes()):
                return entry
        except StopIteration:
            raise ValueError("Attempted to retrieve a non-existing tree node with name: {name}"
                             "".format(name=name))
411256
function getNameFromRoot(root: Object): string {
  // shallow
  if (root.unrendered) {
    const { type } = root.unrendered;
    return type.name || type;
  }

  const inst = instance(root);
  if (inst) {
    return inst._tag;
  }

  // direct node
  if (typeof root.type === 'string') {
    return root.type;
  }

  return typeof root.name === 'function' ? root.name() : '(anonymous)';
}
1326288
function(db) {
    if (!db.type) {
      return defaultDbType;
    }

    return dbTypes.find(function(dbType) {
      return dbType.name === db.type;
    }) || null;
  }
864990
public String getName()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getName");
    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
      SibTr.debug(tc, "No implementation");
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getName", null);
    return null;
  }
1286692
@Nullable
  private static Node getNode(Document doc, String parentNodeName, String targetNodeName) {
    NodeList parentElements = doc.getElementsByTagNameNS(APP_ENGINE_NAMESPACE, parentNodeName);
    if (parentElements.getLength() > 0) {
      Node parent = parentElements.item(0);
      if (parent.hasChildNodes()) {
        for (int i = 0; i < parent.getChildNodes().getLength(); i++) {
          Node child = parent.getChildNodes().item(i);
          if (child.getNodeName().equals(targetNodeName)) {
            return child;
          }
        }
      }
    }
    return null;
  }
810867
def visit_Name(self, node):
        
        if isinstance(node.ctx, ast.Store):
            self.result[node.id] = True
76717
private InternalQName getNodeTypeName(Node config) throws IllegalNameException, RepositoryException
   {
      String ntString = config.getAttributes().getNamedItem("primaryType").getNodeValue();
      return resolver.parseJCRName(ntString).getInternalName();
   }
903036
public String getNodeData(String nodePath,String formId,String tableName,String dataColName,String idColName){

		MicroMetaDao microDao=getInnerDao();
		String select=dataColName+"->>'$."+dianNode(nodePath)+"' as dyna_data";
		String sql="select "+select+" from "+tableName+" where "+idColName+"=?";
		Object[] paramArray=new Object[1];
		paramArray[0]=formId;
		Map retMap=microDao.querySingleObjJoinByCondition(sql,paramArray);
		//返回的一定是个map
		if(retMap!=null){
			return (String) retMap.get("dyna_data");
		}
		
		return null;
	}
1225753
private String determineDatabaseProductName(Connection conn) {
        try {
            final String databaseProductName = conn.getMetaData().getDatabaseProductName().toLowerCase();
            LOGGER.debug("Database product: {}", databaseProductName);
            return databaseProductName;
        } catch (SQLException se) {
            LOGGER.warn("Problem determining database product!", se);
            return null;
        }
    }
176411
def visit_Name(self, node):
        
        if node.id in self.naming:
            return self.naming[node.id]
        elif node.id in self.global_declarations:
            return [frozenset([self.global_declarations[node.id]])]
        elif isinstance(node.ctx, ast.Param):
            deps = [frozenset()]
            self.naming[node.id] = deps
            return deps
        else:
            raise PythranInternalError("Variable '{}' use before assignment"
                                       "".format(node.id))
733440
function () {
                    var name, nameLC, args, alpha_ret, index = i;

                    if (! (name = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(chunks[j]))) return;

                    name = name[1];
                    nameLC = name.toLowerCase();

                    if (nameLC === 'url') { return null }
                    else                  { i += name.length }

                    if (nameLC === 'alpha') {
                        alpha_ret = $(this.alpha);
                        if(typeof alpha_ret !== 'undefined') {
                            return alpha_ret;
                        }
                    }

                    $('('); // Parse the '(' and consume whitespace.

                    args = $(this.entities.arguments);

                    if (! $(')')) {
                        return;
                    }

                    if (name) { return new(tree.Call)(name, args, index, env.currentFileInfo); }
                }
1320065
def getnodefieldname(idfobject, endswith, fluid=None, startswith=None):
    """"""
    if startswith is None:
        startswith = ''
    if fluid is None:
        fluid = ''
    nodenames = getfieldnamesendswith(idfobject, endswith)
    nodenames = [name for name in nodenames if name.startswith(startswith)]
    fnodenames = [nd for nd in nodenames if nd.find(fluid) != -1]
    fnodenames = [name for name in fnodenames if name.startswith(startswith)]
    if len(fnodenames) == 0:
        nodename = nodenames[0]
    else:
        nodename = fnodenames[0]
    return nodename
122857
def get(self, key, name=None):
        """"""
        if name is None:
            self.nodename = self.local_name
            self.nodeid = self.local_id
        else:
            self.logger.debug('Replacing nodename "{0}" with "{1}"'.format(self.nodename, name))
            self.nodename = name
            self.find_name()
        return get_value(self.stats(), fix_key(key))
678868
def getNode(self, name, **context):
        """"""
        if name == self.name:
            return self
        else:
            return self.getBranch(name, **context).getNode(name, **context)